Global

Participantes

• todos
• analysis_test_transition
• any
• archive_override
• aspecto
• bazel_dep
• bind
• bool
• configuration_field
• depset (link em inglês)
• dict
• dir
• enumerate (em inglês)
• exec_group
• reprovar
• float
• getattr (em inglês)
• git_override
• hasattr (em inglês)
• hash
• int
• len
• list
• local_path_override
• max
• mín.
• module
• module_extension
• multiple_version_override
• print
• provedor
• range
• register_execution_platforms()
• register_execution_platforms(dev_dependency)
• register_toolchains()
• register_toolchains(dev_dependency)
• repository_rule
• repr (link em inglês)
• revertido
• regra
• selecionar
• single_version_override
• classificado
• str
• tag_class
• tuple
• tipo
• use_extension
• use_repo
• visibilidade
• espaço de trabalho
• zip

todas

bool all(elements)

all(["hello", 3, True]) == True
all([-1, 0, 1]) == False

Parâmetros

analysis_test_transition

transition analysis_test_transition(settings)

Cria uma transição de configuração para ser aplicada às dependências de uma regra de teste de análise. Essa transição só pode ser aplicada em atributos de regras com analysis_test = True. Essas regras têm recursos restritos (por exemplo, o tamanho da árvore de dependências é limitado). Portanto, as transições criadas usando essa função têm um escopo potencial limitado em comparação com as transições criadas usando transição.

Essa função foi projetada principalmente para facilitar a biblioteca principal do Framework de teste de análise. Consulte a documentação (ou a implementação) para conhecer as práticas recomendadas.

Parâmetros

qualquer um

bool any(elements)

any([-1, 0, 1]) == True
any([False, 0, ""]) == False

Parâmetros

archive_override

None archive_override(module_name, urls, integrity='', strip_prefix='', patches=[], patch_cmds=[], patch_strip=0)

Parâmetros

aspecto

Aspect aspect(implementation, attr_aspects=[], attrs=None, required_providers=[], required_aspect_providers=[], provides=[], requires=[], fragments=[], host_fragments=[], toolchains=[], incompatible_use_toolchain_transition=False, doc='', *, apply_to_generating_rules=False, exec_compatible_with=[], exec_groups=None)

Parâmetros

bazel_dep

None bazel_dep(name, version='', max_compatibility_level=-1, repo_name='', dev_dependency=False)

Parâmetros

bind

None bind(name, actual=None)

Aviso: não recomendamos o uso de bind(). Consulte Considere remover a vinculação para uma longa discussão sobre seus problemas e alternativas.

Fornece a um destino um alias no pacote //external.

Parâmetros

bool

bool bool(x=False)

Parâmetros

configuration_field

LateBoundDefault configuration_field(fragment, name)

Exemplo de uso:

Definindo um atributo de regra:

'_foo': attr.label(default=configuration_field(fragment='java', name='toolchain'))

Acesso na implementação da regra:

  def _rule_impl(ctx):
    foo_info = ctx.attr._foo
    ...

Parâmetros

depset

depset depset(direct=None, order="default", *, transitive=None)

Todos os elementos (diretos e indiretos) de um conjunto de dados precisam ser do mesmo tipo, conforme recebido pela expressão type(x).

Como um conjunto baseado em hash é usado para eliminar duplicatas durante a iteração, todos os elementos de um depset precisam ser hashes. No entanto, essa invariante não é verificada atualmente de forma consistente em todos os construtores. Use a flag --incompatible_always_check_depset_elements para permitir uma verificação consistente. Esse será o comportamento padrão em versões futuras. Consulte o Problema 10313 (link em inglês).

Além disso, os elementos devem ser imutáveis no momento, embora essa restrição seja reduzida no futuro.

A ordem do depset criado deve ser compatível com a ordem de seus depsets transitive. O pedido "default" é compatível com outros pedidos, e os demais são compatíveis apenas com eles próprios.

Observação sobre compatibilidade com versões anteriores/avançadas. No momento, essa função aceita um parâmetro items posicional. Ele foi descontinuado e vai ser removido no futuro. Após a remoção, direct vai se tornar um único parâmetro de posição da função depset. Assim, as duas chamadas a seguir são equivalentes e preparadas para o futuro:

depset(['a', 'b'], transitive = [...])
depset(direct = ['a', 'b'], transitive = [...])

Parâmetros

dict

dict dict(pairs=[], **kwargs)

Parâmetros

dir

list dir(x)

Parâmetros

enumerar

list enumerate(list, start=0)

enumerate([24, 21, 84]) == [(0, 24), (1, 21), (2, 84)]

Parâmetros

exec_group

exec_group exec_group(toolchains=[], exec_compatible_with=[], copy_from_rule=False)

Parâmetros

fail

None fail(msg=None, attr=None, *args)

Parâmetros

float

float float(x=unbound)

• Se x já for um ponto flutuante, float vai retornar o valor inalterado.
• Se x for um booleano, float retornará 1.0 para "True" e 0.0 para "False".
• Se x for um inteiro, float vai retornar o valor de ponto flutuante finito mais próximo de x ou um erro se a magnitude for muito grande.
• Se x for uma string, ele precisará ser um literal de ponto flutuante válido ou ser igual (ignorando maiúsculas e minúsculas) a NaN, Inf ou Infinity, opcionalmente precedido por um sinal + ou -.

Parâmetros

Getattr

unknown getattr(x, name, default=unbound)

getattr(ctx.attr, "myattr")
getattr(ctx.attr, "myattr", "mydefault")

Parâmetros

git_override

None git_override(module_name, remote, commit='', patches=[], patch_cmds=[], patch_strip=0)

Parâmetros

Hasattr

bool hasattr(x, name)

hasattr(ctx.attr, "myattr")

Parâmetros

jogo da velha

int hash(value)

s[0] * (31^(n-1)) + s[1] * (31^(n-2)) + ... + s[n-1]

Parâmetros

int

int int(x, base=unbound)

• Se x já for um int, int o retornará inalterado.
• Se x for um booleano, int retornará 1 para "True" e 0 para "False".
• Se x for uma string, ele precisará ter o formato <sign><prefix><digits>. <sign> é "+", "-" ou está vazio (interpretado como positivo). <digits> são uma sequência de dígitos de 0 a base - 1, em que as letras de a a z (ou equivalente, de A a Z) são usadas como dígitos de 10 a 35. No caso em que base é 2/8/16, <prefix> é opcional e pode ser 0b/0o/0x (ou equivalente, 0B/0O/0X), respectivamente. Se base for qualquer outro valor além dessas bases ou do valor especial 0, o prefixo precisa estar vazio. No caso em que base é 0, a string é interpretada como um literal de número inteiro, no sentido de que uma das bases 2/8/10/16 é escolhida dependendo de qual prefixo, se houver. Se base for 0, nenhum prefixo será usado e houver mais de um dígito, o dígito inicial não poderá ser 0. Isso evita confusão entre octal e decimal. A magnitude do número representado pela string precisa estar dentro do intervalo permitido para o tipo int.
• Se x for um valor flutuante, int vai retornar o valor inteiro do ponto flutuante, arredondando até zero. Se x não for finito (NaN ou infinito), ocorrerá um erro.

Exemplos:

int("123") == 123
int("-123") == -123
int("+123") == 123
int("FF", 16) == 255
int("0xFF", 16) == 255
int("10", 0) == 10
int("-0x10", 0) == -16
int("-0x10", 0) == -16
int("123.456") == 123

Parâmetros

len

int len(x)

Parâmetros

list

list list(x=[])

list([1, 2]) == [1, 2]
list((2, 3, 2)) == [2, 3, 2]
list({5: "a", 2: "b", 4: "c"}) == [5, 2, 4]

Parâmetros

local_path_override

None local_path_override(module_name, path)

Parâmetros

max

unknown max(*args)

max(2, 5, 4) == 5
max([5, 6, 3]) == 6

Parâmetros

min

unknown min(*args)

min(2, 5, 4) == 2
min([5, 6, 3]) == 3

Parâmetros

módulo

None module(name='', version='', compatibility_level=0, repo_name='', bazel_compatibility=[])

Ele deve ser chamado no máximo uma vez. Ele só pode ser omitido se esse módulo for o módulo raiz (por exemplo, se ele não for dependente de outro módulo).

Parâmetros

module_extension

unknown module_extension(implementation, *, tag_classes={}, doc='', environ=[], os_dependent=False, arch_dependent=False)

Parâmetros

multiple_version_override

None multiple_version_override(module_name, versions, registry='')

Parâmetros

mostrar

None print(sep=" ", *args)

Não é recomendável usar print no código de produção devido ao spam criado para os usuários. Para descontinuações, prefira um erro grave usando fail() sempre que possível.

Parâmetros

provider

unknown provider(doc='', *, fields=None, init=None)

MyInfo = provider()
...
def _my_library_impl(ctx):
    ...
    my_info = MyInfo(x = 2, y = 3)
    # my_info.x == 2
    # my_info.y == 3
    ...

Consulte Regras (provedores) para ver um guia completo sobre como usar provedores.

Retorna um valor chamável Provider se init não for especificado.

Se init for especificado, retorna uma tupla de dois elementos: um valor chamável de Provider e um valor chamável do construtor bruto. Consulte Regras (inicialização personalizada de provedores personalizados) e a discussão sobre o parâmetro init abaixo para mais detalhes.

Parâmetros

MyInfo = provider()
m = MyInfo(foo = 1)

MyInfo, _new_myinfo = provider(init = ...)

período

sequence range(start_or_stop, stop_or_none=None, step=1)

range(4) == [0, 1, 2, 3]
range(3, 9, 2) == [3, 5, 7]
range(3, 0, -1) == [3, 2, 1]

Parâmetros

register_execution_platforms()

None register_execution_platforms(*platform_labels)

Parâmetros

register_execution_platforms(dev_dependency)

None register_execution_platforms(dev_dependency=False, *platform_labels)

Parâmetros

register_toolchains()

None register_toolchains(*toolchain_labels)

Parâmetros

register_toolchains(dev_dependency)

None register_toolchains(dev_dependency=False, *toolchain_labels)

Parâmetros

repository_rule

callable repository_rule(implementation, *, attrs=None, local=False, environ=[], configure=False, remotable=False, doc='')

Parâmetros

Repr

string repr(x)

repr("ab") == '"ab"'

Parâmetros

anulou

list reversed(sequence)

reversed([3, 5, 4]) == [4, 5, 3]

Parâmetros

regra

callable rule(implementation, test=False, attrs=None, outputs=None, executable=False, output_to_genfiles=False, fragments=[], host_fragments=[], _skylark_testable=False, toolchains=[], incompatible_use_toolchain_transition=False, doc='', *, provides=[], exec_compatible_with=[], analysis_test=False, build_setting=None, cfg=None, exec_groups=None, compile_one_filetype=None, name=None)

As regras devem ser atribuídas a variáveis globais em um arquivo .bzl. O nome da variável global é o nome da regra.

As regras de teste precisam ter um nome terminado em _test, enquanto todas as outras regras não podem ter esse sufixo. Essa restrição se aplica somente às regras, e não aos destinos delas.

Parâmetros

select

unknown select(x, no_match_error='')

Parâmetros

single_version_override

None single_version_override(module_name, version='', registry='', patches=[], patch_cmds=[], patch_strip=0)

Parâmetros

ordenado

list sorted(iterable, *, key=None, reverse=False)

sorted([3, 5, 4]) == [3, 4, 5]

Parâmetros

str

string str(x)

str("ab") == "ab"
str(8) == "8"

Parâmetros

tag_class

tag_class tag_class(attrs={}, *, doc='')

Parâmetros

tuple

tuple tuple(x=())

tuple([1, 2]) == (1, 2)
tuple((2, 3, 2)) == (2, 3, 2)
tuple({5: "a", 2: "b", 4: "c"}) == (5, 2, 4)

Parâmetros

Tipo

string type(x)

type(2) == "int"
type([1]) == "list"
type(struct(a = 2)) == "struct"

if type(x) == type([]):  # if x is a list

Parâmetros

use_extension

module_extension_proxy use_extension(extension_bzl_file, extension_name, *, dev_dependency=False, isolate=False)

Parâmetros

use_repo

None use_repo(extension_proxy, *args, **kwargs)

Parâmetros

visibilidade

None visibility(value)

Define a visibilidade de carregamento do módulo .bzl que está sendo inicializado.

A visibilidade de carregamento de um módulo determina se outros arquivos BUILD e .bzl podem carregá-lo ou não. Isso é diferente da visibilidade de destino do arquivo de origem .bzl, que determina se o arquivo pode aparecer como uma dependência de outros destinos. A visibilidade de carregamento funciona no nível de pacotes: para carregar um módulo, o arquivo que está fazendo o carregamento deve estar em um pacote com visibilidade para o módulo. Um módulo sempre pode ser carregado dentro do próprio pacote, independentemente da visibilidade dele.

visibility() só pode ser chamado uma vez por arquivo .bzl e apenas no nível superior, não dentro de uma função. O estilo recomendado é colocar essa chamada imediatamente abaixo das instruções load() e de qualquer lógica breve necessária para determinar o argumento.

Se a flag --check_bzl_visibility for definida como falsa, as violações de visibilidade de carregamento vão emitir avisos, mas não vão gerar falha no build.

Parâmetros

espaço de trabalho

None workspace(name)

Essa função só pode ser usada em um arquivo WORKSPACE e precisa ser declarada antes de todas as outras funções no arquivo WORKSPACE. Cada arquivo WORKSPACE precisa ter uma função workspace.

Define o nome desse espaço de trabalho. Os nomes dos espaços de trabalho devem ser uma descrição do projeto no estilo Java, usando sublinhados como separadores. Por exemplo, github.com/bazelbuild/bazel deve usar com_github_bazelbuild_bazel.

Esse nome é usado para o diretório em que os arquivos de execução do repositório estão armazenados. Por exemplo, se houver um arquivo de execução foo/bar no repositório local e o arquivo do ESPAÇO DE TRABALHO contiver workspace(name = 'baz'), ele vai estar disponível em mytarget.runfiles/baz/foo/bar. Se nenhum nome de espaço de trabalho for especificado, o arquivo de execução será vinculado simbólico a bar.runfiles/foo/bar.

Os nomes de regras do repositório remoto precisam ser nomes de espaço de trabalho válidos. Por exemplo, é possível ter maven_jar(name = 'foo'), mas não maven_jar(name = 'foo%bar'), já que o Bazel tentaria gravar um arquivo do ESPAÇO DE TRABALHO para o maven_jar que contém workspace(name = 'foo%bar').

Parâmetros

zip

list zip(*args)

zip()  # == []
zip([1, 2])  # == [(1,), (2,)]
zip([1, 2], [3, 4])  # == [(1, 3), (2, 4)]
zip([1, 2], [3, 4, 5])  # == [(1, 3), (2, 4)]

Parâmetros