github.com/tiagovtristao/plz@v13.4.0+incompatible/src/parse/rules/builtins.build_defs

# Contains declarations of built-in functions & objects


# Do not change the order of arguments to this function unless you feel like
# updating all of targets.go to match it.
def build_rule(name:str, cmd:str|dict='', test_cmd:str|dict='', srcs:list|dict=None, data:list=None, outs:list|dict=None,
               deps:list=None, exported_deps:list=None, secrets:list=None, tools:list|dict=None, labels:list=None,
               visibility:list=CONFIG.DEFAULT_VISIBILITY, hashes:list=None, binary:bool=False, test:bool=False,
               test_only:bool=CONFIG.DEFAULT_TESTONLY, building_description:str=None, needs_transitive_deps:bool=False,
               output_is_complete:bool=False, container:bool|dict=False, sandbox:bool=CONFIG.BUILD_SANDBOX,
               test_sandbox:bool=CONFIG.TEST_SANDBOX, no_test_output:bool=False, flaky:bool|int=0, build_timeout:int=0,
               test_timeout:int=0, pre_build:function=None, post_build:function=None, requires:list=None, provides:dict=None,
               licences:list=CONFIG.DEFAULT_LICENCES, test_outputs:list=None, system_srcs:list=None, stamp:bool=False,
               tag:str='', optional_outs:list=None, progress:bool=False, _urls:list=None):
    pass


def len(obj) -> int:
    pass
def enumerate(seq:list):
    pass
def zip(args):
    pass

def join(self:str, seq:list) -> str:
    pass
def split(self:str, on:str=' ') -> list:
    pass
def replace(self:str, old:str, new:str):
    pass
def partition(self:str, sep:str) -> list:
    pass
def rpartition(self:str, sep:str) -> list:
    pass
def startswith(self:str, s:str) -> bool:
    pass
def endswith(self:str, s:str) -> bool:
    pass
def format(self:str) -> str:
    pass
def lstrip(self:str, cutset:str=' \n') -> str:
    pass
def rstrip(self:str, cutset:str=' \n') -> str:
    pass
def strip(self:str, cutset:str=' \n') -> str:
    pass
def find(self:str, needle:str) -> int:
    pass
def rfind(self:str, needle:str) -> int:
    pass
def count(self:str, needle:str) -> int:
    pass
def upper(self:str) -> str:
    pass
def lower(self:str) -> str:
    pass

def fail(msg:str):
    pass

def subinclude(target:str, hash:str=None):
    pass
def load(target:str, names:str=None):
    pass
def subrepo(name:str, dep:str='', path:str=None, config:str=None, bazel_compat:bool=False):
    pass


def isinstance(obj, types:function|list) -> bool:
    pass


def range(start:int, stop:int=None, step:int=1) -> str:
    pass
def any(seq:list) -> bool:
    for x in seq:
        if x:
            return True
    return False
def all(seq:list) -> bool:
    for x in seq:
        if not x:
            return False
    return True


def bool(b) -> bool:
    pass
def int(s:str) -> int:
    pass
def str(s) -> str:
    pass
def list(l):
    raise 'list is not callable'
def dict(d):
    raise 'dict is not callable'


def glob(include:list, exclude:list&excludes=[], hidden:bool=False) -> list:
    pass


def package():
    pass


def sorted(seq:list) -> list:
    pass


def get(self:dict, key:str, default=None):
    pass
def setdefault(self:config, key:str, default=None) -> config:
    if key in self:
        return self[key]
    self[key] = default
    return default
def config_get(self:config, key:str, default=None) -> config:
    pass


def get_base_path() -> str:
    pass
def package_name() -> str:
    pass

def canonicalise(label:str) -> str:
    """Converts the given build label to its full form.

    For example:
      //package:target -> //package:target
      //package -> //package:package
      :target -> //current_package:target
    """
    pass


def keys(self:dict) -> list:
    pass
def values(self:dict) -> list:
    pass
def items(self:dict) -> list:
    pass
def copy(self:dict) -> dict:
    pass


def git_branch(short:bool=True) -> str:
    raise 'Disabled in config'
def git_commit() -> str:
    raise 'Disabled in config'
def git_show(fmt:str) -> str:
    raise 'Disabled in config'
def git_state(clean_label:str="clean", dirty_label:str="dirty") -> str:
    raise 'Disabled in config'

def debug(args):
    pass
def info(args):
    pass
def notice(args):
    pass
def warning(args):
    pass
def error(args):
    pass
def fatal(args):
    pass

log = {
    'debug': debug,
    'info': info,
    'notice': notice,
    'warning': warning,
    'error': error,
    'fatal': fatal,
}


def join_path(paths:str) -> str:
    pass  # Has to be implemented natively since it's varargs.


def split_path(p:str) -> list:
    before, _, after = p.rpartition('/')
    return before, after


def splitext(p:str) -> list:
    before, dot, after = p.rpartition('.')
    return (before, dot + after) if before else (after, '')


def basename(p:str) -> str:
    """Returns the final component of a pathname"""
    _, _, after = p.rpartition('/')
    return after


def dirname(p:str) -> str:
    """Returns the directory component of a pathname"""
    before, _, after = p.rpartition('/')
    return before


# Exception types.
# There is no actual Exception, but str() is similar enough here.
ParseError = str
ConfigError = str
ValueError = str


# Post-build callback functions.
def get_labels(name:str, prefix:str) -> list:
    pass
def has_label(name:str, prefix:str) -> bool:
    return len(get_labels(name, prefix)) > 0
def add_dep(target:str, dep:str, exported:bool=False):
    pass
def add_exported_dep(target:str, dep:str):
    add_dep(target, dep, True)
def add_out(target:str, name:str, out:str=''):
    pass
def add_licence(target:str, licence:str):
    pass
def get_command(target:str, config:str='') -> str:
    pass
def set_command(target:str, config:str, command:str=''):
    pass


# N.B. This should really be limited so it's only visible when Bazel compat is on,
#      but we currently don't alter the builtins for that scenario.
def licenses(licences):
    """Sets the default licences for the package."""
    assert CONFIG.BAZEL_COMPATIBILITY, 'licenses() can only be called in Bazel compat mode'
    package(default_licences = licences)