ProtoInfo

Encapsula as informações fornecidas pela proto_library.

Considere usar "load("@rules_proto//proto:defs.bzl", "ProtoInfo")` para carregar esse símbolo de rules_proto.

Participantes

check_deps_sources

depset ProtoInfo.check_deps_sources

origens Proto do atributo "srcs". Se for uma biblioteca proxy que não tem fontes, ela conterá o check_deps_sources das dependências diretas dessa biblioteca.

direct_descriptor_set

File ProtoInfo.direct_descriptor_set

O FileDescriptorSet das origens diretas. Se não houver srcs, conterá um arquivo vazio.

direct_sources

list ProtoInfo.direct_sources

origens Proto do atributo "srcs".

proto_source_root

string ProtoInfo.proto_source_root

O diretório relativo ao qual estão definidos os arquivos .proto definidos na proto_library. Por exemplo, se for "a/b" e a regra tiver o arquivo "a/b/c/d.proto" como origem, esse arquivo de origem será importado como "import c/d.proto"

to_json

string ProtoInfo.to_json()

Obsoleto. Esta API foi descontinuada e vai ser removida em breve. Não dependa disso. Ela está desativada com o ---incompatible_struct_has_no_methods. Use essa sinalização para verificar se seu código é compatível com a remoção iminente.
Cria uma string JSON a partir do parâmetro struct. Esse método só funciona se todos os elementos de struct (recursivamente) forem strings, ints, booleanos, outras estruturas, uma lista desses tipos ou um dicionário com chaves de string e valores desses tipos. Aspas e novas linhas em strings têm escape. Por exemplo:
struct(key=123).to_json()
# {"key":123}

struct(key=True).to_json()
# {"key":true}

struct(key=[1, 2, 3]).to_json()
# {"key":[1,2,3]}

struct(key='text').to_json()
# {"key":"text"}

struct(key=struct(inner_key='text')).to_json()
# {"key":{"inner_key":"text"}}

struct(key=[struct(inner_key=1), struct(inner_key=2)]).to_json()
# {"key":[{"inner_key":1},{"inner_key":2}]}

struct(key=struct(inner_key=struct(inner_inner_key='text'))).to_json()
# {"key":{"inner_key":{"inner_inner_key":"text"}}}
.

Obsoleto: em vez disso, use json.encode(x) ou json.encode_indent(x), que funcionam para valores diferentes de structs e não poluem o namespace do campo struct.

to_proto

string ProtoInfo.to_proto()

Obsoleto. Esta API foi descontinuada e vai ser removida em breve. Não dependa disso. Ela está desativada com o ---incompatible_struct_has_no_methods. Use essa sinalização para verificar se seu código é compatível com a remoção iminente.
Cria uma mensagem de texto a partir do parâmetro struct. Esse método só funciona se todos os elementos struct (recursivamente) forem strings, ints, booleanos, outras estruturas, dicts ou listas desses tipos. Aspas e novas linhas em strings têm escape. As chaves struct são iteradas na ordem de classificação. Exemplos:
struct(key=123).to_proto()
# key: 123

struct(key=True).to_proto()
# key: true

struct(key=[1, 2, 3]).to_proto()
# key: 1
# key: 2
# key: 3

struct(key='text').to_proto()
# key: "text"

struct(key=struct(inner_key='text')).to_proto()
# key {
#   inner_key: "text"
# }

struct(key=[struct(inner_key=1), struct(inner_key=2)]).to_proto()
# key {
#   inner_key: 1
# }
# key {
#   inner_key: 2
# }

struct(key=struct(inner_key=struct(inner_inner_key='text'))).to_proto()
# key {
#    inner_key {
#     inner_inner_key: "text"
#   }
# }

struct(foo={4: 3, 2: 1}).to_proto()
# foo: {
#   key: 4
#   value: 3
# }
# foo: {
#   key: 2
#   value: 1
# }

Obsoleto: use proto.encode_text(x).

transitive_descriptor_sets

depset ProtoInfo.transitive_descriptor_sets

Um conjunto de arquivos FileDescriptorSet de todas as regras proto_library dependentes (e este). Isso não é o mesmo que passar --include_imports para o proto-compiler. Será vazio se não houver dependências.

transitive_imports

depset ProtoInfo.transitive_imports

Importações transitivas incluindo dependências fracas.

transitive_proto_path

depset ProtoInfo.transitive_proto_path

Um conjunto de raízes de origem proto coletadas do fechamento transitivo desta regra.

transitive_sources

depset ProtoInfo.transitive_sources

Origens Proto para esta regra e todas as regras de buffer de protocolo dependentes.