diff --git a/scripts/generate_proto_stubs.sh b/scripts/generate_proto_stubs.sh index f7d8cd352..05f63c0d2 100755 --- a/scripts/generate_proto_stubs.sh +++ b/scripts/generate_proto_stubs.sh @@ -9,8 +9,8 @@ # followed by committing the changes to typeshed # # Update these two variables when rerunning script -PROTOBUF_VERSION=3.17.3 -MYPY_PROTOBUF_VERSION=v2.8 +PROTOBUF_VERSION=3.18.1 +MYPY_PROTOBUF_VERSION=v3.0.0 set -ex diff --git a/stubs/protobuf/METADATA.toml b/stubs/protobuf/METADATA.toml index 5e0c83f83..c551073ba 100644 --- a/stubs/protobuf/METADATA.toml +++ b/stubs/protobuf/METADATA.toml @@ -1,4 +1,4 @@ -version = "3.17.*" +version = "3.18.*" python2 = true requires = ["types-futures"] -extra_description = "Generated with aid from mypy-protobuf v2.8" +extra_description = "Generated with aid from mypy-protobuf v3.0.0" diff --git a/stubs/protobuf/google/protobuf/any_pb2.pyi b/stubs/protobuf/google/protobuf/any_pb2.pyi index 063c3b241..4d800b304 100644 --- a/stubs/protobuf/google/protobuf/any_pb2.pyi +++ b/stubs/protobuf/google/protobuf/any_pb2.pyi @@ -11,126 +11,130 @@ import typing_extensions DESCRIPTOR: google.protobuf.descriptor.FileDescriptor = ... -# `Any` contains an arbitrary serialized protocol buffer message along with a -# URL that describes the type of the serialized message. -# -# Protobuf library provides support to pack/unpack Any values in the form -# of utility functions or additional generated methods of the Any type. -# -# Example 1: Pack and unpack a message in C++. -# -# Foo foo = ...; -# Any any; -# any.PackFrom(foo); -# ... -# if (any.UnpackTo(&foo)) { -# ... -# } -# -# Example 2: Pack and unpack a message in Java. -# -# Foo foo = ...; -# Any any = Any.pack(foo); -# ... -# if (any.is(Foo.class)) { -# foo = any.unpack(Foo.class); -# } -# -# Example 3: Pack and unpack a message in Python. -# -# foo = Foo(...) -# any = Any() -# any.Pack(foo) -# ... -# if any.Is(Foo.DESCRIPTOR): -# any.Unpack(foo) -# ... -# -# Example 4: Pack and unpack a message in Go -# -# foo := &pb.Foo{...} -# any, err := anypb.New(foo) -# if err != nil { -# ... -# } -# ... -# foo := &pb.Foo{} -# if err := any.UnmarshalTo(foo); err != nil { -# ... -# } -# -# The pack methods provided by protobuf library will by default use -# 'type.googleapis.com/full.type.name' as the type URL and the unpack -# methods only use the fully qualified type name after the last '/' -# in the type URL, for example "foo.bar.com/x/y.z" will yield type -# name "y.z". -# -# -# JSON -# ==== -# The JSON representation of an `Any` value uses the regular -# representation of the deserialized, embedded message, with an -# additional field `@type` which contains the type URL. Example: -# -# package google.profile; -# message Person { -# string first_name = 1; -# string last_name = 2; -# } -# -# { -# "@type": "type.googleapis.com/google.profile.Person", -# "firstName": , -# "lastName": -# } -# -# If the embedded message type is well-known and has a custom JSON -# representation, that representation will be embedded adding a field -# `value` which holds the custom JSON in addition to the `@type` -# field. Example (for message [google.protobuf.Duration][]): -# -# { -# "@type": "type.googleapis.com/google.protobuf.Duration", -# "value": "1.212s" -# } class Any(google.protobuf.message.Message, google.protobuf.internal.well_known_types.Any): + """`Any` contains an arbitrary serialized protocol buffer message along with a + URL that describes the type of the serialized message. + + Protobuf library provides support to pack/unpack Any values in the form + of utility functions or additional generated methods of the Any type. + + Example 1: Pack and unpack a message in C++. + + Foo foo = ...; + Any any; + any.PackFrom(foo); + ... + if (any.UnpackTo(&foo)) { + ... + } + + Example 2: Pack and unpack a message in Java. + + Foo foo = ...; + Any any = Any.pack(foo); + ... + if (any.is(Foo.class)) { + foo = any.unpack(Foo.class); + } + + Example 3: Pack and unpack a message in Python. + + foo = Foo(...) + any = Any() + any.Pack(foo) + ... + if any.Is(Foo.DESCRIPTOR): + any.Unpack(foo) + ... + + Example 4: Pack and unpack a message in Go + + foo := &pb.Foo{...} + any, err := anypb.New(foo) + if err != nil { + ... + } + ... + foo := &pb.Foo{} + if err := any.UnmarshalTo(foo); err != nil { + ... + } + + The pack methods provided by protobuf library will by default use + 'type.googleapis.com/full.type.name' as the type URL and the unpack + methods only use the fully qualified type name after the last '/' + in the type URL, for example "foo.bar.com/x/y.z" will yield type + name "y.z". + + + JSON + ==== + The JSON representation of an `Any` value uses the regular + representation of the deserialized, embedded message, with an + additional field `@type` which contains the type URL. Example: + + package google.profile; + message Person { + string first_name = 1; + string last_name = 2; + } + + { + "@type": "type.googleapis.com/google.profile.Person", + "firstName": , + "lastName": + } + + If the embedded message type is well-known and has a custom JSON + representation, that representation will be embedded adding a field + `value` which holds the custom JSON in addition to the `@type` + field. Example (for message [google.protobuf.Duration][]): + + { + "@type": "type.googleapis.com/google.protobuf.Duration", + "value": "1.212s" + } + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... TYPE_URL_FIELD_NUMBER: builtins.int VALUE_FIELD_NUMBER: builtins.int - # A URL/resource name that uniquely identifies the type of the serialized - # protocol buffer message. This string must contain at least - # one "/" character. The last segment of the URL's path must represent - # the fully qualified name of the type (as in - # `path/google.protobuf.Duration`). The name should be in a canonical form - # (e.g., leading "." is not accepted). - # - # In practice, teams usually precompile into the binary all types that they - # expect it to use in the context of Any. However, for URLs which use the - # scheme `http`, `https`, or no scheme, one can optionally set up a type - # server that maps type URLs to message definitions as follows: - # - # * If no scheme is provided, `https` is assumed. - # * An HTTP GET on the URL must yield a [google.protobuf.Type][] - # value in binary format, or produce an error. - # * Applications are allowed to cache lookup results based on the - # URL, or have them precompiled into a binary to avoid any - # lookup. Therefore, binary compatibility needs to be preserved - # on changes to types. (Use versioned type names to manage - # breaking changes.) - # - # Note: this functionality is not currently available in the official - # protobuf release, and it is not used for type URLs beginning with - # type.googleapis.com. - # - # Schemes other than `http`, `https` (or the empty scheme) might be - # used with implementation specific semantics. type_url: typing.Text = ... - # Must be a valid serialized protocol buffer of the above specified type. + """A URL/resource name that uniquely identifies the type of the serialized + protocol buffer message. This string must contain at least + one "/" character. The last segment of the URL's path must represent + the fully qualified name of the type (as in + `path/google.protobuf.Duration`). The name should be in a canonical form + (e.g., leading "." is not accepted). + + In practice, teams usually precompile into the binary all types that they + expect it to use in the context of Any. However, for URLs which use the + scheme `http`, `https`, or no scheme, one can optionally set up a type + server that maps type URLs to message definitions as follows: + + * If no scheme is provided, `https` is assumed. + * An HTTP GET on the URL must yield a [google.protobuf.Type][] + value in binary format, or produce an error. + * Applications are allowed to cache lookup results based on the + URL, or have them precompiled into a binary to avoid any + lookup. Therefore, binary compatibility needs to be preserved + on changes to types. (Use versioned type names to manage + breaking changes.) + + Note: this functionality is not currently available in the official + protobuf release, and it is not used for type URLs beginning with + type.googleapis.com. + + Schemes other than `http`, `https` (or the empty scheme) might be + used with implementation specific semantics. + """ + value: builtins.bytes = ... + """Must be a valid serialized protocol buffer of the above specified type.""" + def __init__(self, *, type_url : typing.Text = ..., value : builtins.bytes = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"type_url",b"type_url",u"value",b"value"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["type_url",b"type_url","value",b"value"]) -> None: ... global___Any = Any diff --git a/stubs/protobuf/google/protobuf/api_pb2.pyi b/stubs/protobuf/google/protobuf/api_pb2.pyi index 10d183c44..c7d3dd04c 100644 --- a/stubs/protobuf/google/protobuf/api_pb2.pyi +++ b/stubs/protobuf/google/protobuf/api_pb2.pyi @@ -13,16 +13,17 @@ import typing_extensions DESCRIPTOR: google.protobuf.descriptor.FileDescriptor = ... -# Api is a light-weight descriptor for an API Interface. -# -# Interfaces are also described as "protocol buffer services" in some contexts, -# such as by the "service" keyword in a .proto file, but they are different -# from API Services, which represent a concrete implementation of an interface -# as opposed to simply a description of methods and bindings. They are also -# sometimes simply referred to as "APIs" in other contexts, such as the name of -# this message itself. See https://cloud.google.com/apis/design/glossary for -# detailed terminology. class Api(google.protobuf.message.Message): + """Api is a light-weight descriptor for an API Interface. + + Interfaces are also described as "protocol buffer services" in some contexts, + such as by the "service" keyword in a .proto file, but they are different + from API Services, which represent a concrete implementation of an interface + as opposed to simply a description of methods and bindings. They are also + sometimes simply referred to as "APIs" in other contexts, such as the name of + this message itself. See https://cloud.google.com/apis/design/glossary for + detailed terminology. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_FIELD_NUMBER: builtins.int METHODS_FIELD_NUMBER: builtins.int @@ -31,44 +32,54 @@ class Api(google.protobuf.message.Message): SOURCE_CONTEXT_FIELD_NUMBER: builtins.int MIXINS_FIELD_NUMBER: builtins.int SYNTAX_FIELD_NUMBER: builtins.int - # The fully qualified name of this interface, including package name - # followed by the interface's simple name. name: typing.Text = ... - # The methods of this interface, in unspecified order. + """The fully qualified name of this interface, including package name + followed by the interface's simple name. + """ + @property - def methods(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Method]: ... - # Any metadata attached to the interface. + def methods(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Method]: + """The methods of this interface, in unspecified order.""" + pass @property - def options(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[google.protobuf.type_pb2.Option]: ... - # A version string for this interface. If specified, must have the form - # `major-version.minor-version`, as in `1.10`. If the minor version is - # omitted, it defaults to zero. If the entire version field is empty, the - # major version is derived from the package name, as outlined below. If the - # field is not empty, the version in the package name will be verified to be - # consistent with what is provided here. - # - # The versioning schema uses [semantic - # versioning](http://semver.org) where the major version number - # indicates a breaking change and the minor version an additive, - # non-breaking change. Both version numbers are signals to users - # what to expect from different versions, and should be carefully - # chosen based on the product plan. - # - # The major version is also reflected in the package name of the - # interface, which must end in `v`, as in - # `google.feature.v1`. For major versions 0 and 1, the suffix can - # be omitted. Zero major versions must only be used for - # experimental, non-GA interfaces. + def options(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[google.protobuf.type_pb2.Option]: + """Any metadata attached to the interface.""" + pass version: typing.Text = ... - # Source context for the protocol buffer service represented by this - # message. + """A version string for this interface. If specified, must have the form + `major-version.minor-version`, as in `1.10`. If the minor version is + omitted, it defaults to zero. If the entire version field is empty, the + major version is derived from the package name, as outlined below. If the + field is not empty, the version in the package name will be verified to be + consistent with what is provided here. + + The versioning schema uses [semantic + versioning](http://semver.org) where the major version number + indicates a breaking change and the minor version an additive, + non-breaking change. Both version numbers are signals to users + what to expect from different versions, and should be carefully + chosen based on the product plan. + + The major version is also reflected in the package name of the + interface, which must end in `v`, as in + `google.feature.v1`. For major versions 0 and 1, the suffix can + be omitted. Zero major versions must only be used for + experimental, non-GA interfaces. + """ + @property - def source_context(self) -> google.protobuf.source_context_pb2.SourceContext: ... - # Included interfaces. See [Mixin][]. + def source_context(self) -> google.protobuf.source_context_pb2.SourceContext: + """Source context for the protocol buffer service represented by this + message. + """ + pass @property - def mixins(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Mixin]: ... - # The source syntax of the service. + def mixins(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Mixin]: + """Included interfaces. See [Mixin][].""" + pass syntax: google.protobuf.type_pb2.Syntax.V = ... + """The source syntax of the service.""" + def __init__(self, *, name : typing.Text = ..., @@ -79,12 +90,12 @@ class Api(google.protobuf.message.Message): mixins : typing.Optional[typing.Iterable[global___Mixin]] = ..., syntax : google.protobuf.type_pb2.Syntax.V = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"source_context",b"source_context"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"methods",b"methods",u"mixins",b"mixins",u"name",b"name",u"options",b"options",u"source_context",b"source_context",u"syntax",b"syntax",u"version",b"version"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["source_context",b"source_context"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["methods",b"methods","mixins",b"mixins","name",b"name","options",b"options","source_context",b"source_context","syntax",b"syntax","version",b"version"]) -> None: ... global___Api = Api -# Method represents a method of an API interface. class Method(google.protobuf.message.Message): + """Method represents a method of an API interface.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_FIELD_NUMBER: builtins.int REQUEST_TYPE_URL_FIELD_NUMBER: builtins.int @@ -93,21 +104,28 @@ class Method(google.protobuf.message.Message): RESPONSE_STREAMING_FIELD_NUMBER: builtins.int OPTIONS_FIELD_NUMBER: builtins.int SYNTAX_FIELD_NUMBER: builtins.int - # The simple name of this method. name: typing.Text = ... - # A URL of the input message type. + """The simple name of this method.""" + request_type_url: typing.Text = ... - # If true, the request is streamed. + """A URL of the input message type.""" + request_streaming: builtins.bool = ... - # The URL of the output message type. + """If true, the request is streamed.""" + response_type_url: typing.Text = ... - # If true, the response is streamed. + """The URL of the output message type.""" + response_streaming: builtins.bool = ... - # Any metadata attached to the method. + """If true, the response is streamed.""" + @property - def options(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[google.protobuf.type_pb2.Option]: ... - # The source syntax of this method. + def options(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[google.protobuf.type_pb2.Option]: + """Any metadata attached to the method.""" + pass syntax: google.protobuf.type_pb2.Syntax.V = ... + """The source syntax of this method.""" + def __init__(self, *, name : typing.Text = ..., @@ -118,100 +136,104 @@ class Method(google.protobuf.message.Message): options : typing.Optional[typing.Iterable[google.protobuf.type_pb2.Option]] = ..., syntax : google.protobuf.type_pb2.Syntax.V = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"name",b"name",u"options",b"options",u"request_streaming",b"request_streaming",u"request_type_url",b"request_type_url",u"response_streaming",b"response_streaming",u"response_type_url",b"response_type_url",u"syntax",b"syntax"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["name",b"name","options",b"options","request_streaming",b"request_streaming","request_type_url",b"request_type_url","response_streaming",b"response_streaming","response_type_url",b"response_type_url","syntax",b"syntax"]) -> None: ... global___Method = Method -# Declares an API Interface to be included in this interface. The including -# interface must redeclare all the methods from the included interface, but -# documentation and options are inherited as follows: -# -# - If after comment and whitespace stripping, the documentation -# string of the redeclared method is empty, it will be inherited -# from the original method. -# -# - Each annotation belonging to the service config (http, -# visibility) which is not set in the redeclared method will be -# inherited. -# -# - If an http annotation is inherited, the path pattern will be -# modified as follows. Any version prefix will be replaced by the -# version of the including interface plus the [root][] path if -# specified. -# -# Example of a simple mixin: -# -# package google.acl.v1; -# service AccessControl { -# // Get the underlying ACL object. -# rpc GetAcl(GetAclRequest) returns (Acl) { -# option (google.api.http).get = "/v1/{resource=**}:getAcl"; -# } -# } -# -# package google.storage.v2; -# service Storage { -# rpc GetAcl(GetAclRequest) returns (Acl); -# -# // Get a data record. -# rpc GetData(GetDataRequest) returns (Data) { -# option (google.api.http).get = "/v2/{resource=**}"; -# } -# } -# -# Example of a mixin configuration: -# -# apis: -# - name: google.storage.v2.Storage -# mixins: -# - name: google.acl.v1.AccessControl -# -# The mixin construct implies that all methods in `AccessControl` are -# also declared with same name and request/response types in -# `Storage`. A documentation generator or annotation processor will -# see the effective `Storage.GetAcl` method after inheriting -# documentation and annotations as follows: -# -# service Storage { -# // Get the underlying ACL object. -# rpc GetAcl(GetAclRequest) returns (Acl) { -# option (google.api.http).get = "/v2/{resource=**}:getAcl"; -# } -# ... -# } -# -# Note how the version in the path pattern changed from `v1` to `v2`. -# -# If the `root` field in the mixin is specified, it should be a -# relative path under which inherited HTTP paths are placed. Example: -# -# apis: -# - name: google.storage.v2.Storage -# mixins: -# - name: google.acl.v1.AccessControl -# root: acls -# -# This implies the following inherited HTTP annotation: -# -# service Storage { -# // Get the underlying ACL object. -# rpc GetAcl(GetAclRequest) returns (Acl) { -# option (google.api.http).get = "/v2/acls/{resource=**}:getAcl"; -# } -# ... -# } class Mixin(google.protobuf.message.Message): + """Declares an API Interface to be included in this interface. The including + interface must redeclare all the methods from the included interface, but + documentation and options are inherited as follows: + + - If after comment and whitespace stripping, the documentation + string of the redeclared method is empty, it will be inherited + from the original method. + + - Each annotation belonging to the service config (http, + visibility) which is not set in the redeclared method will be + inherited. + + - If an http annotation is inherited, the path pattern will be + modified as follows. Any version prefix will be replaced by the + version of the including interface plus the [root][] path if + specified. + + Example of a simple mixin: + + package google.acl.v1; + service AccessControl { + // Get the underlying ACL object. + rpc GetAcl(GetAclRequest) returns (Acl) { + option (google.api.http).get = "/v1/{resource=**}:getAcl"; + } + } + + package google.storage.v2; + service Storage { + rpc GetAcl(GetAclRequest) returns (Acl); + + // Get a data record. + rpc GetData(GetDataRequest) returns (Data) { + option (google.api.http).get = "/v2/{resource=**}"; + } + } + + Example of a mixin configuration: + + apis: + - name: google.storage.v2.Storage + mixins: + - name: google.acl.v1.AccessControl + + The mixin construct implies that all methods in `AccessControl` are + also declared with same name and request/response types in + `Storage`. A documentation generator or annotation processor will + see the effective `Storage.GetAcl` method after inheriting + documentation and annotations as follows: + + service Storage { + // Get the underlying ACL object. + rpc GetAcl(GetAclRequest) returns (Acl) { + option (google.api.http).get = "/v2/{resource=**}:getAcl"; + } + ... + } + + Note how the version in the path pattern changed from `v1` to `v2`. + + If the `root` field in the mixin is specified, it should be a + relative path under which inherited HTTP paths are placed. Example: + + apis: + - name: google.storage.v2.Storage + mixins: + - name: google.acl.v1.AccessControl + root: acls + + This implies the following inherited HTTP annotation: + + service Storage { + // Get the underlying ACL object. + rpc GetAcl(GetAclRequest) returns (Acl) { + option (google.api.http).get = "/v2/acls/{resource=**}:getAcl"; + } + ... + } + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_FIELD_NUMBER: builtins.int ROOT_FIELD_NUMBER: builtins.int - # The fully qualified name of the interface which is included. name: typing.Text = ... - # If non-empty specifies a path under which inherited HTTP paths - # are rooted. + """The fully qualified name of the interface which is included.""" + root: typing.Text = ... + """If non-empty specifies a path under which inherited HTTP paths + are rooted. + """ + def __init__(self, *, name : typing.Text = ..., root : typing.Text = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"name",b"name",u"root",b"root"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["name",b"name","root",b"root"]) -> None: ... global___Mixin = Mixin diff --git a/stubs/protobuf/google/protobuf/compiler/plugin_pb2.pyi b/stubs/protobuf/google/protobuf/compiler/plugin_pb2.pyi index 012d8956b..b3e034115 100644 --- a/stubs/protobuf/google/protobuf/compiler/plugin_pb2.pyi +++ b/stubs/protobuf/google/protobuf/compiler/plugin_pb2.pyi @@ -13,8 +13,8 @@ import typing_extensions DESCRIPTOR: google.protobuf.descriptor.FileDescriptor = ... -# The version number of protocol compiler. class Version(google.protobuf.message.Message): + """The version number of protocol compiler.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... MAJOR_FIELD_NUMBER: builtins.int MINOR_FIELD_NUMBER: builtins.int @@ -23,9 +23,11 @@ class Version(google.protobuf.message.Message): major: builtins.int = ... minor: builtins.int = ... patch: builtins.int = ... - # A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should - # be empty for mainline stable releases. suffix: typing.Text = ... + """A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should + be empty for mainline stable releases. + """ + def __init__(self, *, major : typing.Optional[builtins.int] = ..., @@ -33,43 +35,49 @@ class Version(google.protobuf.message.Message): patch : typing.Optional[builtins.int] = ..., suffix : typing.Optional[typing.Text] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"major",b"major",u"minor",b"minor",u"patch",b"patch",u"suffix",b"suffix"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"major",b"major",u"minor",b"minor",u"patch",b"patch",u"suffix",b"suffix"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["major",b"major","minor",b"minor","patch",b"patch","suffix",b"suffix"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["major",b"major","minor",b"minor","patch",b"patch","suffix",b"suffix"]) -> None: ... global___Version = Version -# An encoded CodeGeneratorRequest is written to the plugin's stdin. class CodeGeneratorRequest(google.protobuf.message.Message): + """An encoded CodeGeneratorRequest is written to the plugin's stdin.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... FILE_TO_GENERATE_FIELD_NUMBER: builtins.int PARAMETER_FIELD_NUMBER: builtins.int PROTO_FILE_FIELD_NUMBER: builtins.int COMPILER_VERSION_FIELD_NUMBER: builtins.int - # The .proto files that were explicitly listed on the command-line. The - # code generator should generate code only for these files. Each file's - # descriptor will be included in proto_file, below. @property - def file_to_generate(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]: ... - # The generator parameter passed on the command-line. + def file_to_generate(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]: + """The .proto files that were explicitly listed on the command-line. The + code generator should generate code only for these files. Each file's + descriptor will be included in proto_file, below. + """ + pass parameter: typing.Text = ... - # FileDescriptorProtos for all files in files_to_generate and everything - # they import. The files will appear in topological order, so each file - # appears before any file that imports it. - # - # protoc guarantees that all proto_files will be written after - # the fields above, even though this is not technically guaranteed by the - # protobuf wire format. This theoretically could allow a plugin to stream - # in the FileDescriptorProtos and handle them one by one rather than read - # the entire set into memory at once. However, as of this writing, this - # is not similarly optimized on protoc's end -- it will store all fields in - # memory at once before sending them to the plugin. - # - # Type names of fields and extensions in the FileDescriptorProto are always - # fully qualified. + """The generator parameter passed on the command-line.""" + @property - def proto_file(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[google.protobuf.descriptor_pb2.FileDescriptorProto]: ... - # The version number of protocol compiler. + def proto_file(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[google.protobuf.descriptor_pb2.FileDescriptorProto]: + """FileDescriptorProtos for all files in files_to_generate and everything + they import. The files will appear in topological order, so each file + appears before any file that imports it. + + protoc guarantees that all proto_files will be written after + the fields above, even though this is not technically guaranteed by the + protobuf wire format. This theoretically could allow a plugin to stream + in the FileDescriptorProtos and handle them one by one rather than read + the entire set into memory at once. However, as of this writing, this + is not similarly optimized on protoc's end -- it will store all fields in + memory at once before sending them to the plugin. + + Type names of fields and extensions in the FileDescriptorProto are always + fully qualified. + """ + pass @property - def compiler_version(self) -> global___Version: ... + def compiler_version(self) -> global___Version: + """The version number of protocol compiler.""" + pass def __init__(self, *, file_to_generate : typing.Optional[typing.Iterable[typing.Text]] = ..., @@ -77,15 +85,15 @@ class CodeGeneratorRequest(google.protobuf.message.Message): proto_file : typing.Optional[typing.Iterable[google.protobuf.descriptor_pb2.FileDescriptorProto]] = ..., compiler_version : typing.Optional[global___Version] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"compiler_version",b"compiler_version",u"parameter",b"parameter"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"compiler_version",b"compiler_version",u"file_to_generate",b"file_to_generate",u"parameter",b"parameter",u"proto_file",b"proto_file"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["compiler_version",b"compiler_version","parameter",b"parameter"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["compiler_version",b"compiler_version","file_to_generate",b"file_to_generate","parameter",b"parameter","proto_file",b"proto_file"]) -> None: ... global___CodeGeneratorRequest = CodeGeneratorRequest -# The plugin writes an encoded CodeGeneratorResponse to stdout. class CodeGeneratorResponse(google.protobuf.message.Message): + """The plugin writes an encoded CodeGeneratorResponse to stdout.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... - # Sync with code_generator.h. class Feature(_Feature, metaclass=_FeatureEnumTypeWrapper): + """Sync with code_generator.h.""" pass class _Feature: V = typing.NewType('V', builtins.int) @@ -97,70 +105,77 @@ class CodeGeneratorResponse(google.protobuf.message.Message): FEATURE_NONE = CodeGeneratorResponse.Feature.V(0) FEATURE_PROTO3_OPTIONAL = CodeGeneratorResponse.Feature.V(1) - # Represents a single generated file. class File(google.protobuf.message.Message): + """Represents a single generated file.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_FIELD_NUMBER: builtins.int INSERTION_POINT_FIELD_NUMBER: builtins.int CONTENT_FIELD_NUMBER: builtins.int GENERATED_CODE_INFO_FIELD_NUMBER: builtins.int - # The file name, relative to the output directory. The name must not - # contain "." or ".." components and must be relative, not be absolute (so, - # the file cannot lie outside the output directory). "/" must be used as - # the path separator, not "\". - # - # If the name is omitted, the content will be appended to the previous - # file. This allows the generator to break large files into small chunks, - # and allows the generated text to be streamed back to protoc so that large - # files need not reside completely in memory at one time. Note that as of - # this writing protoc does not optimize for this -- it will read the entire - # CodeGeneratorResponse before writing files to disk. name: typing.Text = ... - # If non-empty, indicates that the named file should already exist, and the - # content here is to be inserted into that file at a defined insertion - # point. This feature allows a code generator to extend the output - # produced by another code generator. The original generator may provide - # insertion points by placing special annotations in the file that look - # like: - # @@protoc_insertion_point(NAME) - # The annotation can have arbitrary text before and after it on the line, - # which allows it to be placed in a comment. NAME should be replaced with - # an identifier naming the point -- this is what other generators will use - # as the insertion_point. Code inserted at this point will be placed - # immediately above the line containing the insertion point (thus multiple - # insertions to the same point will come out in the order they were added). - # The double-@ is intended to make it unlikely that the generated code - # could contain things that look like insertion points by accident. - # - # For example, the C++ code generator places the following line in the - # .pb.h files that it generates: - # // @@protoc_insertion_point(namespace_scope) - # This line appears within the scope of the file's package namespace, but - # outside of any particular class. Another plugin can then specify the - # insertion_point "namespace_scope" to generate additional classes or - # other declarations that should be placed in this scope. - # - # Note that if the line containing the insertion point begins with - # whitespace, the same whitespace will be added to every line of the - # inserted text. This is useful for languages like Python, where - # indentation matters. In these languages, the insertion point comment - # should be indented the same amount as any inserted code will need to be - # in order to work correctly in that context. - # - # The code generator that generates the initial file and the one which - # inserts into it must both run as part of a single invocation of protoc. - # Code generators are executed in the order in which they appear on the - # command line. - # - # If |insertion_point| is present, |name| must also be present. + """The file name, relative to the output directory. The name must not + contain "." or ".." components and must be relative, not be absolute (so, + the file cannot lie outside the output directory). "/" must be used as + the path separator, not "\\". + + If the name is omitted, the content will be appended to the previous + file. This allows the generator to break large files into small chunks, + and allows the generated text to be streamed back to protoc so that large + files need not reside completely in memory at one time. Note that as of + this writing protoc does not optimize for this -- it will read the entire + CodeGeneratorResponse before writing files to disk. + """ + insertion_point: typing.Text = ... - # The file contents. + """If non-empty, indicates that the named file should already exist, and the + content here is to be inserted into that file at a defined insertion + point. This feature allows a code generator to extend the output + produced by another code generator. The original generator may provide + insertion points by placing special annotations in the file that look + like: + @@protoc_insertion_point(NAME) + The annotation can have arbitrary text before and after it on the line, + which allows it to be placed in a comment. NAME should be replaced with + an identifier naming the point -- this is what other generators will use + as the insertion_point. Code inserted at this point will be placed + immediately above the line containing the insertion point (thus multiple + insertions to the same point will come out in the order they were added). + The double-@ is intended to make it unlikely that the generated code + could contain things that look like insertion points by accident. + + For example, the C++ code generator places the following line in the + .pb.h files that it generates: + // @@protoc_insertion_point(namespace_scope) + This line appears within the scope of the file's package namespace, but + outside of any particular class. Another plugin can then specify the + insertion_point "namespace_scope" to generate additional classes or + other declarations that should be placed in this scope. + + Note that if the line containing the insertion point begins with + whitespace, the same whitespace will be added to every line of the + inserted text. This is useful for languages like Python, where + indentation matters. In these languages, the insertion point comment + should be indented the same amount as any inserted code will need to be + in order to work correctly in that context. + + The code generator that generates the initial file and the one which + inserts into it must both run as part of a single invocation of protoc. + Code generators are executed in the order in which they appear on the + command line. + + If |insertion_point| is present, |name| must also be present. + """ + content: typing.Text = ... - # Information describing the file content being inserted. If an insertion - # point is used, this information will be appropriately offset and inserted - # into the code generation metadata for the generated files. + """The file contents.""" + @property - def generated_code_info(self) -> google.protobuf.descriptor_pb2.GeneratedCodeInfo: ... + def generated_code_info(self) -> google.protobuf.descriptor_pb2.GeneratedCodeInfo: + """Information describing the file content being inserted. If an insertion + point is used, this information will be appropriately offset and inserted + into the code generation metadata for the generated files. + """ + pass def __init__(self, *, name : typing.Optional[typing.Text] = ..., @@ -168,24 +183,28 @@ class CodeGeneratorResponse(google.protobuf.message.Message): content : typing.Optional[typing.Text] = ..., generated_code_info : typing.Optional[google.protobuf.descriptor_pb2.GeneratedCodeInfo] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"content",b"content",u"generated_code_info",b"generated_code_info",u"insertion_point",b"insertion_point",u"name",b"name"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"content",b"content",u"generated_code_info",b"generated_code_info",u"insertion_point",b"insertion_point",u"name",b"name"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["content",b"content","generated_code_info",b"generated_code_info","insertion_point",b"insertion_point","name",b"name"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["content",b"content","generated_code_info",b"generated_code_info","insertion_point",b"insertion_point","name",b"name"]) -> None: ... ERROR_FIELD_NUMBER: builtins.int SUPPORTED_FEATURES_FIELD_NUMBER: builtins.int FILE_FIELD_NUMBER: builtins.int - # Error message. If non-empty, code generation failed. The plugin process - # should exit with status code zero even if it reports an error in this way. - # - # This should be used to indicate errors in .proto files which prevent the - # code generator from generating correct code. Errors which indicate a - # problem in protoc itself -- such as the input CodeGeneratorRequest being - # unparseable -- should be reported by writing a message to stderr and - # exiting with a non-zero status code. error: typing.Text = ... - # A bitmask of supported features that the code generator supports. - # This is a bitwise "or" of values from the Feature enum. + """Error message. If non-empty, code generation failed. The plugin process + should exit with status code zero even if it reports an error in this way. + + This should be used to indicate errors in .proto files which prevent the + code generator from generating correct code. Errors which indicate a + problem in protoc itself -- such as the input CodeGeneratorRequest being + unparseable -- should be reported by writing a message to stderr and + exiting with a non-zero status code. + """ + supported_features: builtins.int = ... + """A bitmask of supported features that the code generator supports. + This is a bitwise "or" of values from the Feature enum. + """ + @property def file(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___CodeGeneratorResponse.File]: ... def __init__(self, @@ -194,6 +213,6 @@ class CodeGeneratorResponse(google.protobuf.message.Message): supported_features : typing.Optional[builtins.int] = ..., file : typing.Optional[typing.Iterable[global___CodeGeneratorResponse.File]] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"error",b"error",u"supported_features",b"supported_features"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"error",b"error",u"file",b"file",u"supported_features",b"supported_features"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["error",b"error","supported_features",b"supported_features"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["error",b"error","file",b"file","supported_features",b"supported_features"]) -> None: ... global___CodeGeneratorResponse = CodeGeneratorResponse diff --git a/stubs/protobuf/google/protobuf/descriptor_pb2.pyi b/stubs/protobuf/google/protobuf/descriptor_pb2.pyi index 2a8a5b11f..555c15131 100644 --- a/stubs/protobuf/google/protobuf/descriptor_pb2.pyi +++ b/stubs/protobuf/google/protobuf/descriptor_pb2.pyi @@ -12,9 +12,10 @@ import typing_extensions DESCRIPTOR: google.protobuf.descriptor.FileDescriptor = ... -# The protocol compiler can output a FileDescriptorSet containing the .proto -# files it parses. class FileDescriptorSet(google.protobuf.message.Message): + """The protocol compiler can output a FileDescriptorSet containing the .proto + files it parses. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... FILE_FIELD_NUMBER: builtins.int @property @@ -23,11 +24,11 @@ class FileDescriptorSet(google.protobuf.message.Message): *, file : typing.Optional[typing.Iterable[global___FileDescriptorProto]] = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"file",b"file"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["file",b"file"]) -> None: ... global___FileDescriptorSet = FileDescriptorSet -# Describes a complete .proto file. class FileDescriptorProto(google.protobuf.message.Message): + """Describes a complete .proto file.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_FIELD_NUMBER: builtins.int PACKAGE_FIELD_NUMBER: builtins.int @@ -41,23 +42,30 @@ class FileDescriptorProto(google.protobuf.message.Message): OPTIONS_FIELD_NUMBER: builtins.int SOURCE_CODE_INFO_FIELD_NUMBER: builtins.int SYNTAX_FIELD_NUMBER: builtins.int - # file name, relative to root of source tree name: typing.Text = ... - # e.g. "foo", "foo.bar", etc. + """file name, relative to root of source tree""" + package: typing.Text = ... - # Names of files imported by this file. + """e.g. "foo", "foo.bar", etc.""" + @property - def dependency(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]: ... - # Indexes of the public imported files in the dependency list above. + def dependency(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]: + """Names of files imported by this file.""" + pass @property - def public_dependency(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: ... - # Indexes of the weak imported files in the dependency list. - # For Google-internal migration only. Do not use. + def public_dependency(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: + """Indexes of the public imported files in the dependency list above.""" + pass @property - def weak_dependency(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: ... - # All top-level definitions in this file. + def weak_dependency(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: + """Indexes of the weak imported files in the dependency list. + For Google-internal migration only. Do not use. + """ + pass @property - def message_type(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___DescriptorProto]: ... + def message_type(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___DescriptorProto]: + """All top-level definitions in this file.""" + pass @property def enum_type(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___EnumDescriptorProto]: ... @property @@ -66,15 +74,19 @@ class FileDescriptorProto(google.protobuf.message.Message): def extension(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___FieldDescriptorProto]: ... @property def options(self) -> global___FileOptions: ... - # This field contains optional information about the original source code. - # You may safely remove this entire field without harming runtime - # functionality of the descriptors -- the information is needed only by - # development tools. @property - def source_code_info(self) -> global___SourceCodeInfo: ... - # The syntax of the proto file. - # The supported values are "proto2" and "proto3". + def source_code_info(self) -> global___SourceCodeInfo: + """This field contains optional information about the original source code. + You may safely remove this entire field without harming runtime + functionality of the descriptors -- the information is needed only by + development tools. + """ + pass syntax: typing.Text = ... + """The syntax of the proto file. + The supported values are "proto2" and "proto3". + """ + def __init__(self, *, name : typing.Optional[typing.Text] = ..., @@ -90,22 +102,24 @@ class FileDescriptorProto(google.protobuf.message.Message): source_code_info : typing.Optional[global___SourceCodeInfo] = ..., syntax : typing.Optional[typing.Text] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"name",b"name",u"options",b"options",u"package",b"package",u"source_code_info",b"source_code_info",u"syntax",b"syntax"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"dependency",b"dependency",u"enum_type",b"enum_type",u"extension",b"extension",u"message_type",b"message_type",u"name",b"name",u"options",b"options",u"package",b"package",u"public_dependency",b"public_dependency",u"service",b"service",u"source_code_info",b"source_code_info",u"syntax",b"syntax",u"weak_dependency",b"weak_dependency"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["name",b"name","options",b"options","package",b"package","source_code_info",b"source_code_info","syntax",b"syntax"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["dependency",b"dependency","enum_type",b"enum_type","extension",b"extension","message_type",b"message_type","name",b"name","options",b"options","package",b"package","public_dependency",b"public_dependency","service",b"service","source_code_info",b"source_code_info","syntax",b"syntax","weak_dependency",b"weak_dependency"]) -> None: ... global___FileDescriptorProto = FileDescriptorProto -# Describes a message type. class DescriptorProto(google.protobuf.message.Message): + """Describes a message type.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... class ExtensionRange(google.protobuf.message.Message): DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... START_FIELD_NUMBER: builtins.int END_FIELD_NUMBER: builtins.int OPTIONS_FIELD_NUMBER: builtins.int - # Inclusive. start: builtins.int = ... - # Exclusive. + """Inclusive.""" + end: builtins.int = ... + """Exclusive.""" + @property def options(self) -> global___ExtensionRangeOptions: ... def __init__(self, @@ -114,27 +128,30 @@ class DescriptorProto(google.protobuf.message.Message): end : typing.Optional[builtins.int] = ..., options : typing.Optional[global___ExtensionRangeOptions] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"end",b"end",u"options",b"options",u"start",b"start"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"end",b"end",u"options",b"options",u"start",b"start"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["end",b"end","options",b"options","start",b"start"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["end",b"end","options",b"options","start",b"start"]) -> None: ... - # Range of reserved tag numbers. Reserved tag numbers may not be used by - # fields or extension ranges in the same message. Reserved ranges may - # not overlap. class ReservedRange(google.protobuf.message.Message): + """Range of reserved tag numbers. Reserved tag numbers may not be used by + fields or extension ranges in the same message. Reserved ranges may + not overlap. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... START_FIELD_NUMBER: builtins.int END_FIELD_NUMBER: builtins.int - # Inclusive. start: builtins.int = ... - # Exclusive. + """Inclusive.""" + end: builtins.int = ... + """Exclusive.""" + def __init__(self, *, start : typing.Optional[builtins.int] = ..., end : typing.Optional[builtins.int] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"end",b"end",u"start",b"start"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"end",b"end",u"start",b"start"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["end",b"end","start",b"start"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["end",b"end","start",b"start"]) -> None: ... NAME_FIELD_NUMBER: builtins.int FIELD_FIELD_NUMBER: builtins.int @@ -163,10 +180,12 @@ class DescriptorProto(google.protobuf.message.Message): def options(self) -> global___MessageOptions: ... @property def reserved_range(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___DescriptorProto.ReservedRange]: ... - # Reserved field names, which may not be used by fields in the same message. - # A given name may only be reserved once. @property - def reserved_name(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]: ... + def reserved_name(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]: + """Reserved field names, which may not be used by fields in the same message. + A given name may only be reserved once. + """ + pass def __init__(self, *, name : typing.Optional[typing.Text] = ..., @@ -180,25 +199,26 @@ class DescriptorProto(google.protobuf.message.Message): reserved_range : typing.Optional[typing.Iterable[global___DescriptorProto.ReservedRange]] = ..., reserved_name : typing.Optional[typing.Iterable[typing.Text]] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"name",b"name",u"options",b"options"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"enum_type",b"enum_type",u"extension",b"extension",u"extension_range",b"extension_range",u"field",b"field",u"name",b"name",u"nested_type",b"nested_type",u"oneof_decl",b"oneof_decl",u"options",b"options",u"reserved_name",b"reserved_name",u"reserved_range",b"reserved_range"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["name",b"name","options",b"options"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["enum_type",b"enum_type","extension",b"extension","extension_range",b"extension_range","field",b"field","name",b"name","nested_type",b"nested_type","oneof_decl",b"oneof_decl","options",b"options","reserved_name",b"reserved_name","reserved_range",b"reserved_range"]) -> None: ... global___DescriptorProto = DescriptorProto class ExtensionRangeOptions(google.protobuf.message.Message): DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int - # The parser stores options it doesn't recognize here. See above. @property - def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: ... + def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: + """The parser stores options it doesn't recognize here. See above.""" + pass def __init__(self, *, uninterpreted_option : typing.Optional[typing.Iterable[global___UninterpretedOption]] = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["uninterpreted_option",b"uninterpreted_option"]) -> None: ... global___ExtensionRangeOptions = ExtensionRangeOptions -# Describes a field within a message. class FieldDescriptorProto(google.protobuf.message.Message): + """Describes a field within a message.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... class Type(_Type, metaclass=_TypeEnumTypeWrapper): pass @@ -206,71 +226,95 @@ class FieldDescriptorProto(google.protobuf.message.Message): V = typing.NewType('V', builtins.int) class _TypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_Type.V], builtins.type): DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor = ... - # 0 is reserved for errors. - # Order is weird for historical reasons. TYPE_DOUBLE = FieldDescriptorProto.Type.V(1) + """0 is reserved for errors. + Order is weird for historical reasons. + """ + TYPE_FLOAT = FieldDescriptorProto.Type.V(2) - # Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if - # negative values are likely. TYPE_INT64 = FieldDescriptorProto.Type.V(3) + """Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + negative values are likely. + """ + TYPE_UINT64 = FieldDescriptorProto.Type.V(4) - # Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if - # negative values are likely. TYPE_INT32 = FieldDescriptorProto.Type.V(5) + """Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + negative values are likely. + """ + TYPE_FIXED64 = FieldDescriptorProto.Type.V(6) TYPE_FIXED32 = FieldDescriptorProto.Type.V(7) TYPE_BOOL = FieldDescriptorProto.Type.V(8) TYPE_STRING = FieldDescriptorProto.Type.V(9) - # Tag-delimited aggregate. - # Group type is deprecated and not supported in proto3. However, Proto3 - # implementations should still be able to parse the group wire format and - # treat group fields as unknown fields. TYPE_GROUP = FieldDescriptorProto.Type.V(10) - # Length-delimited aggregate. + """Tag-delimited aggregate. + Group type is deprecated and not supported in proto3. However, Proto3 + implementations should still be able to parse the group wire format and + treat group fields as unknown fields. + """ + TYPE_MESSAGE = FieldDescriptorProto.Type.V(11) - # New in version 2. + """Length-delimited aggregate.""" + TYPE_BYTES = FieldDescriptorProto.Type.V(12) + """New in version 2.""" + TYPE_UINT32 = FieldDescriptorProto.Type.V(13) TYPE_ENUM = FieldDescriptorProto.Type.V(14) TYPE_SFIXED32 = FieldDescriptorProto.Type.V(15) TYPE_SFIXED64 = FieldDescriptorProto.Type.V(16) - # Uses ZigZag encoding. TYPE_SINT32 = FieldDescriptorProto.Type.V(17) - # Uses ZigZag encoding. - TYPE_SINT64 = FieldDescriptorProto.Type.V(18) + """Uses ZigZag encoding.""" + + TYPE_SINT64 = FieldDescriptorProto.Type.V(18) + """Uses ZigZag encoding.""" + - # 0 is reserved for errors. - # Order is weird for historical reasons. TYPE_DOUBLE = FieldDescriptorProto.Type.V(1) + """0 is reserved for errors. + Order is weird for historical reasons. + """ + TYPE_FLOAT = FieldDescriptorProto.Type.V(2) - # Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if - # negative values are likely. TYPE_INT64 = FieldDescriptorProto.Type.V(3) + """Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + negative values are likely. + """ + TYPE_UINT64 = FieldDescriptorProto.Type.V(4) - # Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if - # negative values are likely. TYPE_INT32 = FieldDescriptorProto.Type.V(5) + """Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + negative values are likely. + """ + TYPE_FIXED64 = FieldDescriptorProto.Type.V(6) TYPE_FIXED32 = FieldDescriptorProto.Type.V(7) TYPE_BOOL = FieldDescriptorProto.Type.V(8) TYPE_STRING = FieldDescriptorProto.Type.V(9) - # Tag-delimited aggregate. - # Group type is deprecated and not supported in proto3. However, Proto3 - # implementations should still be able to parse the group wire format and - # treat group fields as unknown fields. TYPE_GROUP = FieldDescriptorProto.Type.V(10) - # Length-delimited aggregate. + """Tag-delimited aggregate. + Group type is deprecated and not supported in proto3. However, Proto3 + implementations should still be able to parse the group wire format and + treat group fields as unknown fields. + """ + TYPE_MESSAGE = FieldDescriptorProto.Type.V(11) - # New in version 2. + """Length-delimited aggregate.""" + TYPE_BYTES = FieldDescriptorProto.Type.V(12) + """New in version 2.""" + TYPE_UINT32 = FieldDescriptorProto.Type.V(13) TYPE_ENUM = FieldDescriptorProto.Type.V(14) TYPE_SFIXED32 = FieldDescriptorProto.Type.V(15) TYPE_SFIXED64 = FieldDescriptorProto.Type.V(16) - # Uses ZigZag encoding. TYPE_SINT32 = FieldDescriptorProto.Type.V(17) - # Uses ZigZag encoding. + """Uses ZigZag encoding.""" + TYPE_SINT64 = FieldDescriptorProto.Type.V(18) + """Uses ZigZag encoding.""" + class Label(_Label, metaclass=_LabelEnumTypeWrapper): pass @@ -278,13 +322,15 @@ class FieldDescriptorProto(google.protobuf.message.Message): V = typing.NewType('V', builtins.int) class _LabelEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_Label.V], builtins.type): DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor = ... - # 0 is reserved for errors LABEL_OPTIONAL = FieldDescriptorProto.Label.V(1) + """0 is reserved for errors""" + LABEL_REQUIRED = FieldDescriptorProto.Label.V(2) LABEL_REPEATED = FieldDescriptorProto.Label.V(3) - # 0 is reserved for errors LABEL_OPTIONAL = FieldDescriptorProto.Label.V(1) + """0 is reserved for errors""" + LABEL_REQUIRED = FieldDescriptorProto.Label.V(2) LABEL_REPEATED = FieldDescriptorProto.Label.V(3) @@ -302,56 +348,70 @@ class FieldDescriptorProto(google.protobuf.message.Message): name: typing.Text = ... number: builtins.int = ... label: global___FieldDescriptorProto.Label.V = ... - # If type_name is set, this need not be set. If both this and type_name - # are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. type: global___FieldDescriptorProto.Type.V = ... - # For message and enum types, this is the name of the type. If the name - # starts with a '.', it is fully-qualified. Otherwise, C++-like scoping - # rules are used to find the type (i.e. first the nested types within this - # message are searched, then within the parent, on up to the root - # namespace). + """If type_name is set, this need not be set. If both this and type_name + are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + """ + type_name: typing.Text = ... - # For extensions, this is the name of the type being extended. It is - # resolved in the same manner as type_name. + """For message and enum types, this is the name of the type. If the name + starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + rules are used to find the type (i.e. first the nested types within this + message are searched, then within the parent, on up to the root + namespace). + """ + extendee: typing.Text = ... - # For numeric types, contains the original text representation of the value. - # For booleans, "true" or "false". - # For strings, contains the default text contents (not escaped in any way). - # For bytes, contains the C escaped value. All bytes >= 128 are escaped. - # TODO(kenton): Base-64 encode? + """For extensions, this is the name of the type being extended. It is + resolved in the same manner as type_name. + """ + default_value: typing.Text = ... - # If set, gives the index of a oneof in the containing type's oneof_decl - # list. This field is a member of that oneof. + """For numeric types, contains the original text representation of the value. + For booleans, "true" or "false". + For strings, contains the default text contents (not escaped in any way). + For bytes, contains the C escaped value. All bytes >= 128 are escaped. + TODO(kenton): Base-64 encode? + """ + oneof_index: builtins.int = ... - # JSON name of this field. The value is set by protocol compiler. If the - # user has set a "json_name" option on this field, that option's value - # will be used. Otherwise, it's deduced from the field's name by converting - # it to camelCase. + """If set, gives the index of a oneof in the containing type's oneof_decl + list. This field is a member of that oneof. + """ + json_name: typing.Text = ... + """JSON name of this field. The value is set by protocol compiler. If the + user has set a "json_name" option on this field, that option's value + will be used. Otherwise, it's deduced from the field's name by converting + it to camelCase. + """ + @property def options(self) -> global___FieldOptions: ... - # If true, this is a proto3 "optional". When a proto3 field is optional, it - # tracks presence regardless of field type. - # - # When proto3_optional is true, this field must be belong to a oneof to - # signal to old proto3 clients that presence is tracked for this field. This - # oneof is known as a "synthetic" oneof, and this field must be its sole - # member (each proto3 optional field gets its own synthetic oneof). Synthetic - # oneofs exist in the descriptor only, and do not generate any API. Synthetic - # oneofs must be ordered after all "real" oneofs. - # - # For message fields, proto3_optional doesn't create any semantic change, - # since non-repeated message fields always track presence. However it still - # indicates the semantic detail of whether the user wrote "optional" or not. - # This can be useful for round-tripping the .proto file. For consistency we - # give message fields a synthetic oneof also, even though it is not required - # to track presence. This is especially important because the parser can't - # tell if a field is a message or an enum, so it must always create a - # synthetic oneof. - # - # Proto2 optional fields do not set this flag, because they already indicate - # optional with `LABEL_OPTIONAL`. proto3_optional: builtins.bool = ... + """If true, this is a proto3 "optional". When a proto3 field is optional, it + tracks presence regardless of field type. + + When proto3_optional is true, this field must be belong to a oneof to + signal to old proto3 clients that presence is tracked for this field. This + oneof is known as a "synthetic" oneof, and this field must be its sole + member (each proto3 optional field gets its own synthetic oneof). Synthetic + oneofs exist in the descriptor only, and do not generate any API. Synthetic + oneofs must be ordered after all "real" oneofs. + + For message fields, proto3_optional doesn't create any semantic change, + since non-repeated message fields always track presence. However it still + indicates the semantic detail of whether the user wrote "optional" or not. + This can be useful for round-tripping the .proto file. For consistency we + give message fields a synthetic oneof also, even though it is not required + to track presence. This is especially important because the parser can't + tell if a field is a message or an enum, so it must always create a + synthetic oneof. + + Proto2 optional fields do not set this flag, because they already indicate + optional with `LABEL_OPTIONAL`. + """ + def __init__(self, *, name : typing.Optional[typing.Text] = ..., @@ -366,12 +426,12 @@ class FieldDescriptorProto(google.protobuf.message.Message): options : typing.Optional[global___FieldOptions] = ..., proto3_optional : typing.Optional[builtins.bool] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"default_value",b"default_value",u"extendee",b"extendee",u"json_name",b"json_name",u"label",b"label",u"name",b"name",u"number",b"number",u"oneof_index",b"oneof_index",u"options",b"options",u"proto3_optional",b"proto3_optional",u"type",b"type",u"type_name",b"type_name"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"default_value",b"default_value",u"extendee",b"extendee",u"json_name",b"json_name",u"label",b"label",u"name",b"name",u"number",b"number",u"oneof_index",b"oneof_index",u"options",b"options",u"proto3_optional",b"proto3_optional",u"type",b"type",u"type_name",b"type_name"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["default_value",b"default_value","extendee",b"extendee","json_name",b"json_name","label",b"label","name",b"name","number",b"number","oneof_index",b"oneof_index","options",b"options","proto3_optional",b"proto3_optional","type",b"type","type_name",b"type_name"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["default_value",b"default_value","extendee",b"extendee","json_name",b"json_name","label",b"label","name",b"name","number",b"number","oneof_index",b"oneof_index","options",b"options","proto3_optional",b"proto3_optional","type",b"type","type_name",b"type_name"]) -> None: ... global___FieldDescriptorProto = FieldDescriptorProto -# Describes a oneof. class OneofDescriptorProto(google.protobuf.message.Message): + """Describes a oneof.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_FIELD_NUMBER: builtins.int OPTIONS_FIELD_NUMBER: builtins.int @@ -383,34 +443,37 @@ class OneofDescriptorProto(google.protobuf.message.Message): name : typing.Optional[typing.Text] = ..., options : typing.Optional[global___OneofOptions] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"name",b"name",u"options",b"options"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"name",b"name",u"options",b"options"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["name",b"name","options",b"options"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["name",b"name","options",b"options"]) -> None: ... global___OneofDescriptorProto = OneofDescriptorProto -# Describes an enum type. class EnumDescriptorProto(google.protobuf.message.Message): + """Describes an enum type.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... - # Range of reserved numeric values. Reserved values may not be used by - # entries in the same enum. Reserved ranges may not overlap. - # - # Note that this is distinct from DescriptorProto.ReservedRange in that it - # is inclusive such that it can appropriately represent the entire int32 - # domain. class EnumReservedRange(google.protobuf.message.Message): + """Range of reserved numeric values. Reserved values may not be used by + entries in the same enum. Reserved ranges may not overlap. + + Note that this is distinct from DescriptorProto.ReservedRange in that it + is inclusive such that it can appropriately represent the entire int32 + domain. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... START_FIELD_NUMBER: builtins.int END_FIELD_NUMBER: builtins.int - # Inclusive. start: builtins.int = ... - # Inclusive. + """Inclusive.""" + end: builtins.int = ... + """Inclusive.""" + def __init__(self, *, start : typing.Optional[builtins.int] = ..., end : typing.Optional[builtins.int] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"end",b"end",u"start",b"start"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"end",b"end",u"start",b"start"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["end",b"end","start",b"start"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["end",b"end","start",b"start"]) -> None: ... NAME_FIELD_NUMBER: builtins.int VALUE_FIELD_NUMBER: builtins.int @@ -422,15 +485,19 @@ class EnumDescriptorProto(google.protobuf.message.Message): def value(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___EnumValueDescriptorProto]: ... @property def options(self) -> global___EnumOptions: ... - # Range of reserved numeric values. Reserved numeric values may not be used - # by enum values in the same enum declaration. Reserved ranges may not - # overlap. @property - def reserved_range(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___EnumDescriptorProto.EnumReservedRange]: ... - # Reserved enum value names, which may not be reused. A given name may only - # be reserved once. + def reserved_range(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___EnumDescriptorProto.EnumReservedRange]: + """Range of reserved numeric values. Reserved numeric values may not be used + by enum values in the same enum declaration. Reserved ranges may not + overlap. + """ + pass @property - def reserved_name(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]: ... + def reserved_name(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]: + """Reserved enum value names, which may not be reused. A given name may only + be reserved once. + """ + pass def __init__(self, *, name : typing.Optional[typing.Text] = ..., @@ -439,12 +506,12 @@ class EnumDescriptorProto(google.protobuf.message.Message): reserved_range : typing.Optional[typing.Iterable[global___EnumDescriptorProto.EnumReservedRange]] = ..., reserved_name : typing.Optional[typing.Iterable[typing.Text]] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"name",b"name",u"options",b"options"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"name",b"name",u"options",b"options",u"reserved_name",b"reserved_name",u"reserved_range",b"reserved_range",u"value",b"value"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["name",b"name","options",b"options"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["name",b"name","options",b"options","reserved_name",b"reserved_name","reserved_range",b"reserved_range","value",b"value"]) -> None: ... global___EnumDescriptorProto = EnumDescriptorProto -# Describes a value within an enum. class EnumValueDescriptorProto(google.protobuf.message.Message): + """Describes a value within an enum.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_FIELD_NUMBER: builtins.int NUMBER_FIELD_NUMBER: builtins.int @@ -459,12 +526,12 @@ class EnumValueDescriptorProto(google.protobuf.message.Message): number : typing.Optional[builtins.int] = ..., options : typing.Optional[global___EnumValueOptions] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"name",b"name",u"number",b"number",u"options",b"options"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"name",b"name",u"number",b"number",u"options",b"options"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["name",b"name","number",b"number","options",b"options"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["name",b"name","number",b"number","options",b"options"]) -> None: ... global___EnumValueDescriptorProto = EnumValueDescriptorProto -# Describes a service. class ServiceDescriptorProto(google.protobuf.message.Message): + """Describes a service.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_FIELD_NUMBER: builtins.int METHOD_FIELD_NUMBER: builtins.int @@ -480,12 +547,12 @@ class ServiceDescriptorProto(google.protobuf.message.Message): method : typing.Optional[typing.Iterable[global___MethodDescriptorProto]] = ..., options : typing.Optional[global___ServiceOptions] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"name",b"name",u"options",b"options"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"method",b"method",u"name",b"name",u"options",b"options"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["name",b"name","options",b"options"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["method",b"method","name",b"name","options",b"options"]) -> None: ... global___ServiceDescriptorProto = ServiceDescriptorProto -# Describes a method of a service. class MethodDescriptorProto(google.protobuf.message.Message): + """Describes a method of a service.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_FIELD_NUMBER: builtins.int INPUT_TYPE_FIELD_NUMBER: builtins.int @@ -494,16 +561,20 @@ class MethodDescriptorProto(google.protobuf.message.Message): CLIENT_STREAMING_FIELD_NUMBER: builtins.int SERVER_STREAMING_FIELD_NUMBER: builtins.int name: typing.Text = ... - # Input and output type names. These are resolved in the same way as - # FieldDescriptorProto.type_name, but must refer to a message type. input_type: typing.Text = ... + """Input and output type names. These are resolved in the same way as + FieldDescriptorProto.type_name, but must refer to a message type. + """ + output_type: typing.Text = ... @property def options(self) -> global___MethodOptions: ... - # Identifies if client streams multiple client messages client_streaming: builtins.bool = ... - # Identifies if server streams multiple server messages + """Identifies if client streams multiple client messages""" + server_streaming: builtins.bool = ... + """Identifies if server streams multiple server messages""" + def __init__(self, *, name : typing.Optional[typing.Text] = ..., @@ -513,66 +584,75 @@ class MethodDescriptorProto(google.protobuf.message.Message): client_streaming : typing.Optional[builtins.bool] = ..., server_streaming : typing.Optional[builtins.bool] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"client_streaming",b"client_streaming",u"input_type",b"input_type",u"name",b"name",u"options",b"options",u"output_type",b"output_type",u"server_streaming",b"server_streaming"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"client_streaming",b"client_streaming",u"input_type",b"input_type",u"name",b"name",u"options",b"options",u"output_type",b"output_type",u"server_streaming",b"server_streaming"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["client_streaming",b"client_streaming","input_type",b"input_type","name",b"name","options",b"options","output_type",b"output_type","server_streaming",b"server_streaming"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["client_streaming",b"client_streaming","input_type",b"input_type","name",b"name","options",b"options","output_type",b"output_type","server_streaming",b"server_streaming"]) -> None: ... global___MethodDescriptorProto = MethodDescriptorProto -# =================================================================== -# Options - -# Each of the definitions above may have "options" attached. These are -# just annotations which may cause code to be generated slightly differently -# or may contain hints for code that manipulates protocol messages. -# -# Clients may define custom options as extensions of the *Options messages. -# These extensions may not yet be known at parsing time, so the parser cannot -# store the values in them. Instead it stores them in a field in the *Options -# message called uninterpreted_option. This field must have the same name -# across all *Options messages. We then use this field to populate the -# extensions when we build a descriptor, at which point all protos have been -# parsed and so all extensions are known. -# -# Extension numbers for custom options may be chosen as follows: -# * For options which will only be used within a single application or -# organization, or for experimental options, use field numbers 50000 -# through 99999. It is up to you to ensure that you do not use the -# same number for multiple options. -# * For options which will be published and used publicly by multiple -# independent entities, e-mail protobuf-global-extension-registry@google.com -# to reserve extension numbers. Simply provide your project name (e.g. -# Objective-C plugin) and your project website (if available) -- there's no -# need to explain how you intend to use them. Usually you only need one -# extension number. You can declare multiple options with only one extension -# number by putting them in a sub-message. See the Custom Options section of -# the docs for examples: -# https://developers.google.com/protocol-buffers/docs/proto#options -# If this turns out to be popular, a web service will be set up -# to automatically assign option numbers. - class FileOptions(google.protobuf.message.Message): + """=================================================================== + Options + + Each of the definitions above may have "options" attached. These are + just annotations which may cause code to be generated slightly differently + or may contain hints for code that manipulates protocol messages. + + Clients may define custom options as extensions of the *Options messages. + These extensions may not yet be known at parsing time, so the parser cannot + store the values in them. Instead it stores them in a field in the *Options + message called uninterpreted_option. This field must have the same name + across all *Options messages. We then use this field to populate the + extensions when we build a descriptor, at which point all protos have been + parsed and so all extensions are known. + + Extension numbers for custom options may be chosen as follows: + * For options which will only be used within a single application or + organization, or for experimental options, use field numbers 50000 + through 99999. It is up to you to ensure that you do not use the + same number for multiple options. + * For options which will be published and used publicly by multiple + independent entities, e-mail protobuf-global-extension-registry@google.com + to reserve extension numbers. Simply provide your project name (e.g. + Objective-C plugin) and your project website (if available) -- there's no + need to explain how you intend to use them. Usually you only need one + extension number. You can declare multiple options with only one extension + number by putting them in a sub-message. See the Custom Options section of + the docs for examples: + https://developers.google.com/protocol-buffers/docs/proto#options + If this turns out to be popular, a web service will be set up + to automatically assign option numbers. + + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... - # Generated classes can be optimized for speed or code size. class OptimizeMode(_OptimizeMode, metaclass=_OptimizeModeEnumTypeWrapper): + """Generated classes can be optimized for speed or code size.""" pass class _OptimizeMode: V = typing.NewType('V', builtins.int) class _OptimizeModeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_OptimizeMode.V], builtins.type): DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor = ... - # Generate complete code for parsing, serialization, SPEED = FileOptions.OptimizeMode.V(1) - # etc. - # Use ReflectionOps to implement these methods. - CODE_SIZE = FileOptions.OptimizeMode.V(2) - # Generate code using MessageLite and the lite runtime. - LITE_RUNTIME = FileOptions.OptimizeMode.V(3) + """Generate complete code for parsing, serialization,""" + + CODE_SIZE = FileOptions.OptimizeMode.V(2) + """etc. + Use ReflectionOps to implement these methods. + """ + + LITE_RUNTIME = FileOptions.OptimizeMode.V(3) + """Generate code using MessageLite and the lite runtime.""" + - # Generate complete code for parsing, serialization, SPEED = FileOptions.OptimizeMode.V(1) - # etc. - # Use ReflectionOps to implement these methods. + """Generate complete code for parsing, serialization,""" + CODE_SIZE = FileOptions.OptimizeMode.V(2) - # Generate code using MessageLite and the lite runtime. + """etc. + Use ReflectionOps to implement these methods. + """ + LITE_RUNTIME = FileOptions.OptimizeMode.V(3) + """Generate code using MessageLite and the lite runtime.""" + JAVA_PACKAGE_FIELD_NUMBER: builtins.int JAVA_OUTER_CLASSNAME_FIELD_NUMBER: builtins.int @@ -595,91 +675,123 @@ class FileOptions(google.protobuf.message.Message): PHP_METADATA_NAMESPACE_FIELD_NUMBER: builtins.int RUBY_PACKAGE_FIELD_NUMBER: builtins.int UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int - # Sets the Java package where classes generated from this .proto will be - # placed. By default, the proto package is used, but this is often - # inappropriate because proto packages do not normally start with backwards - # domain names. java_package: typing.Text = ... - # Controls the name of the wrapper Java class generated for the .proto file. - # That class will always contain the .proto file's getDescriptor() method as - # well as any top-level extensions defined in the .proto file. - # If java_multiple_files is disabled, then all the other classes from the - # .proto file will be nested inside the single wrapper outer class. + """Sets the Java package where classes generated from this .proto will be + placed. By default, the proto package is used, but this is often + inappropriate because proto packages do not normally start with backwards + domain names. + """ + java_outer_classname: typing.Text = ... - # If enabled, then the Java code generator will generate a separate .java - # file for each top-level message, enum, and service defined in the .proto - # file. Thus, these types will *not* be nested inside the wrapper class - # named by java_outer_classname. However, the wrapper class will still be - # generated to contain the file's getDescriptor() method as well as any - # top-level extensions defined in the file. + """Controls the name of the wrapper Java class generated for the .proto file. + That class will always contain the .proto file's getDescriptor() method as + well as any top-level extensions defined in the .proto file. + If java_multiple_files is disabled, then all the other classes from the + .proto file will be nested inside the single wrapper outer class. + """ + java_multiple_files: builtins.bool = ... - # This option does nothing. + """If enabled, then the Java code generator will generate a separate .java + file for each top-level message, enum, and service defined in the .proto + file. Thus, these types will *not* be nested inside the wrapper class + named by java_outer_classname. However, the wrapper class will still be + generated to contain the file's getDescriptor() method as well as any + top-level extensions defined in the file. + """ + java_generate_equals_and_hash: builtins.bool = ... - # If set true, then the Java2 code generator will generate code that - # throws an exception whenever an attempt is made to assign a non-UTF-8 - # byte sequence to a string field. - # Message reflection will do the same. - # However, an extension field still accepts non-UTF-8 byte sequences. - # This option has no effect on when used with the lite runtime. + """This option does nothing.""" + java_string_check_utf8: builtins.bool = ... + """If set true, then the Java2 code generator will generate code that + throws an exception whenever an attempt is made to assign a non-UTF-8 + byte sequence to a string field. + Message reflection will do the same. + However, an extension field still accepts non-UTF-8 byte sequences. + This option has no effect on when used with the lite runtime. + """ + optimize_for: global___FileOptions.OptimizeMode.V = ... - # Sets the Go package where structs generated from this .proto will be - # placed. If omitted, the Go package will be derived from the following: - # - The basename of the package import path, if provided. - # - Otherwise, the package statement in the .proto file, if present. - # - Otherwise, the basename of the .proto file, without extension. go_package: typing.Text = ... - # Should generic services be generated in each language? "Generic" services - # are not specific to any particular RPC system. They are generated by the - # main code generators in each language (without additional plugins). - # Generic services were the only kind of service generation supported by - # early versions of google.protobuf. - # - # Generic services are now considered deprecated in favor of using plugins - # that generate code specific to your particular RPC system. Therefore, - # these default to false. Old code which depends on generic services should - # explicitly set them to true. + """Sets the Go package where structs generated from this .proto will be + placed. If omitted, the Go package will be derived from the following: + - The basename of the package import path, if provided. + - Otherwise, the package statement in the .proto file, if present. + - Otherwise, the basename of the .proto file, without extension. + """ + cc_generic_services: builtins.bool = ... + """Should generic services be generated in each language? "Generic" services + are not specific to any particular RPC system. They are generated by the + main code generators in each language (without additional plugins). + Generic services were the only kind of service generation supported by + early versions of google.protobuf. + + Generic services are now considered deprecated in favor of using plugins + that generate code specific to your particular RPC system. Therefore, + these default to false. Old code which depends on generic services should + explicitly set them to true. + """ + java_generic_services: builtins.bool = ... py_generic_services: builtins.bool = ... php_generic_services: builtins.bool = ... - # Is this file deprecated? - # Depending on the target platform, this can emit Deprecated annotations - # for everything in the file, or it will be completely ignored; in the very - # least, this is a formalization for deprecating files. deprecated: builtins.bool = ... - # Enables the use of arenas for the proto messages in this file. This applies - # only to generated classes for C++. + """Is this file deprecated? + Depending on the target platform, this can emit Deprecated annotations + for everything in the file, or it will be completely ignored; in the very + least, this is a formalization for deprecating files. + """ + cc_enable_arenas: builtins.bool = ... - # Sets the objective c class prefix which is prepended to all objective c - # generated classes from this .proto. There is no default. + """Enables the use of arenas for the proto messages in this file. This applies + only to generated classes for C++. + """ + objc_class_prefix: typing.Text = ... - # Namespace for generated classes; defaults to the package. + """Sets the objective c class prefix which is prepended to all objective c + generated classes from this .proto. There is no default. + """ + csharp_namespace: typing.Text = ... - # By default Swift generators will take the proto package and CamelCase it - # replacing '.' with underscore and use that to prefix the types/symbols - # defined. When this options is provided, they will use this value instead - # to prefix the types/symbols defined. + """Namespace for generated classes; defaults to the package.""" + swift_prefix: typing.Text = ... - # Sets the php class prefix which is prepended to all php generated classes - # from this .proto. Default is empty. + """By default Swift generators will take the proto package and CamelCase it + replacing '.' with underscore and use that to prefix the types/symbols + defined. When this options is provided, they will use this value instead + to prefix the types/symbols defined. + """ + php_class_prefix: typing.Text = ... - # Use this option to change the namespace of php generated classes. Default - # is empty. When this option is empty, the package name will be used for - # determining the namespace. + """Sets the php class prefix which is prepended to all php generated classes + from this .proto. Default is empty. + """ + php_namespace: typing.Text = ... - # Use this option to change the namespace of php generated metadata classes. - # Default is empty. When this option is empty, the proto file name will be - # used for determining the namespace. + """Use this option to change the namespace of php generated classes. Default + is empty. When this option is empty, the package name will be used for + determining the namespace. + """ + php_metadata_namespace: typing.Text = ... - # Use this option to change the package of ruby generated classes. Default - # is empty. When this option is not set, the package name will be used for - # determining the ruby package. + """Use this option to change the namespace of php generated metadata classes. + Default is empty. When this option is empty, the proto file name will be + used for determining the namespace. + """ + ruby_package: typing.Text = ... - # The parser stores options it doesn't recognize here. - # See the documentation for the "Options" section above. + """Use this option to change the package of ruby generated classes. Default + is empty. When this option is not set, the package name will be used for + determining the ruby package. + """ + @property - def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: ... + def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: + """The parser stores options it doesn't recognize here. + See the documentation for the "Options" section above. + """ + pass def __init__(self, *, java_package : typing.Optional[typing.Text] = ..., @@ -704,8 +816,8 @@ class FileOptions(google.protobuf.message.Message): ruby_package : typing.Optional[typing.Text] = ..., uninterpreted_option : typing.Optional[typing.Iterable[global___UninterpretedOption]] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"cc_enable_arenas",b"cc_enable_arenas",u"cc_generic_services",b"cc_generic_services",u"csharp_namespace",b"csharp_namespace",u"deprecated",b"deprecated",u"go_package",b"go_package",u"java_generate_equals_and_hash",b"java_generate_equals_and_hash",u"java_generic_services",b"java_generic_services",u"java_multiple_files",b"java_multiple_files",u"java_outer_classname",b"java_outer_classname",u"java_package",b"java_package",u"java_string_check_utf8",b"java_string_check_utf8",u"objc_class_prefix",b"objc_class_prefix",u"optimize_for",b"optimize_for",u"php_class_prefix",b"php_class_prefix",u"php_generic_services",b"php_generic_services",u"php_metadata_namespace",b"php_metadata_namespace",u"php_namespace",b"php_namespace",u"py_generic_services",b"py_generic_services",u"ruby_package",b"ruby_package",u"swift_prefix",b"swift_prefix"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"cc_enable_arenas",b"cc_enable_arenas",u"cc_generic_services",b"cc_generic_services",u"csharp_namespace",b"csharp_namespace",u"deprecated",b"deprecated",u"go_package",b"go_package",u"java_generate_equals_and_hash",b"java_generate_equals_and_hash",u"java_generic_services",b"java_generic_services",u"java_multiple_files",b"java_multiple_files",u"java_outer_classname",b"java_outer_classname",u"java_package",b"java_package",u"java_string_check_utf8",b"java_string_check_utf8",u"objc_class_prefix",b"objc_class_prefix",u"optimize_for",b"optimize_for",u"php_class_prefix",b"php_class_prefix",u"php_generic_services",b"php_generic_services",u"php_metadata_namespace",b"php_metadata_namespace",u"php_namespace",b"php_namespace",u"py_generic_services",b"py_generic_services",u"ruby_package",b"ruby_package",u"swift_prefix",b"swift_prefix",u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["cc_enable_arenas",b"cc_enable_arenas","cc_generic_services",b"cc_generic_services","csharp_namespace",b"csharp_namespace","deprecated",b"deprecated","go_package",b"go_package","java_generate_equals_and_hash",b"java_generate_equals_and_hash","java_generic_services",b"java_generic_services","java_multiple_files",b"java_multiple_files","java_outer_classname",b"java_outer_classname","java_package",b"java_package","java_string_check_utf8",b"java_string_check_utf8","objc_class_prefix",b"objc_class_prefix","optimize_for",b"optimize_for","php_class_prefix",b"php_class_prefix","php_generic_services",b"php_generic_services","php_metadata_namespace",b"php_metadata_namespace","php_namespace",b"php_namespace","py_generic_services",b"py_generic_services","ruby_package",b"ruby_package","swift_prefix",b"swift_prefix"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["cc_enable_arenas",b"cc_enable_arenas","cc_generic_services",b"cc_generic_services","csharp_namespace",b"csharp_namespace","deprecated",b"deprecated","go_package",b"go_package","java_generate_equals_and_hash",b"java_generate_equals_and_hash","java_generic_services",b"java_generic_services","java_multiple_files",b"java_multiple_files","java_outer_classname",b"java_outer_classname","java_package",b"java_package","java_string_check_utf8",b"java_string_check_utf8","objc_class_prefix",b"objc_class_prefix","optimize_for",b"optimize_for","php_class_prefix",b"php_class_prefix","php_generic_services",b"php_generic_services","php_metadata_namespace",b"php_metadata_namespace","php_namespace",b"php_namespace","py_generic_services",b"py_generic_services","ruby_package",b"ruby_package","swift_prefix",b"swift_prefix","uninterpreted_option",b"uninterpreted_option"]) -> None: ... global___FileOptions = FileOptions class MessageOptions(google.protobuf.message.Message): @@ -715,59 +827,68 @@ class MessageOptions(google.protobuf.message.Message): DEPRECATED_FIELD_NUMBER: builtins.int MAP_ENTRY_FIELD_NUMBER: builtins.int UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int - # Set true to use the old proto1 MessageSet wire format for extensions. - # This is provided for backwards-compatibility with the MessageSet wire - # format. You should not use this for any other reason: It's less - # efficient, has fewer features, and is more complicated. - # - # The message must be defined exactly as follows: - # message Foo { - # option message_set_wire_format = true; - # extensions 4 to max; - # } - # Note that the message cannot have any defined fields; MessageSets only - # have extensions. - # - # All extensions of your type must be singular messages; e.g. they cannot - # be int32s, enums, or repeated messages. - # - # Because this is an option, the above two restrictions are not enforced by - # the protocol compiler. message_set_wire_format: builtins.bool = ... - # Disables the generation of the standard "descriptor()" accessor, which can - # conflict with a field of the same name. This is meant to make migration - # from proto1 easier; new code should avoid fields named "descriptor". + """Set true to use the old proto1 MessageSet wire format for extensions. + This is provided for backwards-compatibility with the MessageSet wire + format. You should not use this for any other reason: It's less + efficient, has fewer features, and is more complicated. + + The message must be defined exactly as follows: + message Foo { + option message_set_wire_format = true; + extensions 4 to max; + } + Note that the message cannot have any defined fields; MessageSets only + have extensions. + + All extensions of your type must be singular messages; e.g. they cannot + be int32s, enums, or repeated messages. + + Because this is an option, the above two restrictions are not enforced by + the protocol compiler. + """ + no_standard_descriptor_accessor: builtins.bool = ... - # Is this message deprecated? - # Depending on the target platform, this can emit Deprecated annotations - # for the message, or it will be completely ignored; in the very least, - # this is a formalization for deprecating messages. + """Disables the generation of the standard "descriptor()" accessor, which can + conflict with a field of the same name. This is meant to make migration + from proto1 easier; new code should avoid fields named "descriptor". + """ + deprecated: builtins.bool = ... - # Whether the message is an automatically generated map entry type for the - # maps field. - # - # For maps fields: - # map map_field = 1; - # The parsed descriptor looks like: - # message MapFieldEntry { - # option map_entry = true; - # optional KeyType key = 1; - # optional ValueType value = 2; - # } - # repeated MapFieldEntry map_field = 1; - # - # Implementations may choose not to generate the map_entry=true message, but - # use a native map in the target language to hold the keys and values. - # The reflection APIs in such implementations still need to work as - # if the field is a repeated message field. - # - # NOTE: Do not set the option in .proto files. Always use the maps syntax - # instead. The option should only be implicitly set by the proto compiler - # parser. + """Is this message deprecated? + Depending on the target platform, this can emit Deprecated annotations + for the message, or it will be completely ignored; in the very least, + this is a formalization for deprecating messages. + """ + map_entry: builtins.bool = ... - # The parser stores options it doesn't recognize here. See above. + """Whether the message is an automatically generated map entry type for the + maps field. + + For maps fields: + map map_field = 1; + The parsed descriptor looks like: + message MapFieldEntry { + option map_entry = true; + optional KeyType key = 1; + optional ValueType value = 2; + } + repeated MapFieldEntry map_field = 1; + + Implementations may choose not to generate the map_entry=true message, but + use a native map in the target language to hold the keys and values. + The reflection APIs in such implementations still need to work as + if the field is a repeated message field. + + NOTE: Do not set the option in .proto files. Always use the maps syntax + instead. The option should only be implicitly set by the proto compiler + parser. + """ + @property - def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: ... + def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: + """The parser stores options it doesn't recognize here. See above.""" + pass def __init__(self, *, message_set_wire_format : typing.Optional[builtins.bool] = ..., @@ -776,8 +897,8 @@ class MessageOptions(google.protobuf.message.Message): map_entry : typing.Optional[builtins.bool] = ..., uninterpreted_option : typing.Optional[typing.Iterable[global___UninterpretedOption]] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"deprecated",b"deprecated",u"map_entry",b"map_entry",u"message_set_wire_format",b"message_set_wire_format",u"no_standard_descriptor_accessor",b"no_standard_descriptor_accessor"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"deprecated",b"deprecated",u"map_entry",b"map_entry",u"message_set_wire_format",b"message_set_wire_format",u"no_standard_descriptor_accessor",b"no_standard_descriptor_accessor",u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["deprecated",b"deprecated","map_entry",b"map_entry","message_set_wire_format",b"message_set_wire_format","no_standard_descriptor_accessor",b"no_standard_descriptor_accessor"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["deprecated",b"deprecated","map_entry",b"map_entry","message_set_wire_format",b"message_set_wire_format","no_standard_descriptor_accessor",b"no_standard_descriptor_accessor","uninterpreted_option",b"uninterpreted_option"]) -> None: ... global___MessageOptions = MessageOptions class FieldOptions(google.protobuf.message.Message): @@ -788,13 +909,15 @@ class FieldOptions(google.protobuf.message.Message): V = typing.NewType('V', builtins.int) class _CTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_CType.V], builtins.type): DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor = ... - # Default mode. STRING = FieldOptions.CType.V(0) + """Default mode.""" + CORD = FieldOptions.CType.V(1) STRING_PIECE = FieldOptions.CType.V(2) - # Default mode. STRING = FieldOptions.CType.V(0) + """Default mode.""" + CORD = FieldOptions.CType.V(1) STRING_PIECE = FieldOptions.CType.V(2) @@ -804,19 +927,25 @@ class FieldOptions(google.protobuf.message.Message): V = typing.NewType('V', builtins.int) class _JSTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_JSType.V], builtins.type): DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor = ... - # Use the default type. JS_NORMAL = FieldOptions.JSType.V(0) - # Use JavaScript strings. - JS_STRING = FieldOptions.JSType.V(1) - # Use JavaScript numbers. - JS_NUMBER = FieldOptions.JSType.V(2) + """Use the default type.""" + + JS_STRING = FieldOptions.JSType.V(1) + """Use JavaScript strings.""" + + JS_NUMBER = FieldOptions.JSType.V(2) + """Use JavaScript numbers.""" + - # Use the default type. JS_NORMAL = FieldOptions.JSType.V(0) - # Use JavaScript strings. + """Use the default type.""" + JS_STRING = FieldOptions.JSType.V(1) - # Use JavaScript numbers. + """Use JavaScript strings.""" + JS_NUMBER = FieldOptions.JSType.V(2) + """Use JavaScript numbers.""" + CTYPE_FIELD_NUMBER: builtins.int PACKED_FIELD_NUMBER: builtins.int @@ -825,68 +954,80 @@ class FieldOptions(google.protobuf.message.Message): DEPRECATED_FIELD_NUMBER: builtins.int WEAK_FIELD_NUMBER: builtins.int UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int - # The ctype option instructs the C++ code generator to use a different - # representation of the field than it normally would. See the specific - # options below. This option is not yet implemented in the open source - # release -- sorry, we'll try to include it in a future version! ctype: global___FieldOptions.CType.V = ... - # The packed option can be enabled for repeated primitive fields to enable - # a more efficient representation on the wire. Rather than repeatedly - # writing the tag and type for each element, the entire array is encoded as - # a single length-delimited blob. In proto3, only explicit setting it to - # false will avoid using packed encoding. + """The ctype option instructs the C++ code generator to use a different + representation of the field than it normally would. See the specific + options below. This option is not yet implemented in the open source + release -- sorry, we'll try to include it in a future version! + """ + packed: builtins.bool = ... - # The jstype option determines the JavaScript type used for values of the - # field. The option is permitted only for 64 bit integral and fixed types - # (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING - # is represented as JavaScript string, which avoids loss of precision that - # can happen when a large value is converted to a floating point JavaScript. - # Specifying JS_NUMBER for the jstype causes the generated JavaScript code to - # use the JavaScript "number" type. The behavior of the default option - # JS_NORMAL is implementation dependent. - # - # This option is an enum to permit additional types to be added, e.g. - # goog.math.Integer. + """The packed option can be enabled for repeated primitive fields to enable + a more efficient representation on the wire. Rather than repeatedly + writing the tag and type for each element, the entire array is encoded as + a single length-delimited blob. In proto3, only explicit setting it to + false will avoid using packed encoding. + """ + jstype: global___FieldOptions.JSType.V = ... - # Should this field be parsed lazily? Lazy applies only to message-type - # fields. It means that when the outer message is initially parsed, the - # inner message's contents will not be parsed but instead stored in encoded - # form. The inner message will actually be parsed when it is first accessed. - # - # This is only a hint. Implementations are free to choose whether to use - # eager or lazy parsing regardless of the value of this option. However, - # setting this option true suggests that the protocol author believes that - # using lazy parsing on this field is worth the additional bookkeeping - # overhead typically needed to implement it. - # - # This option does not affect the public interface of any generated code; - # all method signatures remain the same. Furthermore, thread-safety of the - # interface is not affected by this option; const methods remain safe to - # call from multiple threads concurrently, while non-const methods continue - # to require exclusive access. - # - # - # Note that implementations may choose not to check required fields within - # a lazy sub-message. That is, calling IsInitialized() on the outer message - # may return true even if the inner message has missing required fields. - # This is necessary because otherwise the inner message would have to be - # parsed in order to perform the check, defeating the purpose of lazy - # parsing. An implementation which chooses not to check required fields - # must be consistent about it. That is, for any particular sub-message, the - # implementation must either *always* check its required fields, or *never* - # check its required fields, regardless of whether or not the message has - # been parsed. + """The jstype option determines the JavaScript type used for values of the + field. The option is permitted only for 64 bit integral and fixed types + (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING + is represented as JavaScript string, which avoids loss of precision that + can happen when a large value is converted to a floating point JavaScript. + Specifying JS_NUMBER for the jstype causes the generated JavaScript code to + use the JavaScript "number" type. The behavior of the default option + JS_NORMAL is implementation dependent. + + This option is an enum to permit additional types to be added, e.g. + goog.math.Integer. + """ + lazy: builtins.bool = ... - # Is this field deprecated? - # Depending on the target platform, this can emit Deprecated annotations - # for accessors, or it will be completely ignored; in the very least, this - # is a formalization for deprecating fields. + """Should this field be parsed lazily? Lazy applies only to message-type + fields. It means that when the outer message is initially parsed, the + inner message's contents will not be parsed but instead stored in encoded + form. The inner message will actually be parsed when it is first accessed. + + This is only a hint. Implementations are free to choose whether to use + eager or lazy parsing regardless of the value of this option. However, + setting this option true suggests that the protocol author believes that + using lazy parsing on this field is worth the additional bookkeeping + overhead typically needed to implement it. + + This option does not affect the public interface of any generated code; + all method signatures remain the same. Furthermore, thread-safety of the + interface is not affected by this option; const methods remain safe to + call from multiple threads concurrently, while non-const methods continue + to require exclusive access. + + + Note that implementations may choose not to check required fields within + a lazy sub-message. That is, calling IsInitialized() on the outer message + may return true even if the inner message has missing required fields. + This is necessary because otherwise the inner message would have to be + parsed in order to perform the check, defeating the purpose of lazy + parsing. An implementation which chooses not to check required fields + must be consistent about it. That is, for any particular sub-message, the + implementation must either *always* check its required fields, or *never* + check its required fields, regardless of whether or not the message has + been parsed. + """ + deprecated: builtins.bool = ... - # For Google-internal migration only. Do not use. + """Is this field deprecated? + Depending on the target platform, this can emit Deprecated annotations + for accessors, or it will be completely ignored; in the very least, this + is a formalization for deprecating fields. + """ + weak: builtins.bool = ... - # The parser stores options it doesn't recognize here. See above. + """For Google-internal migration only. Do not use.""" + @property - def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: ... + def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: + """The parser stores options it doesn't recognize here. See above.""" + pass def __init__(self, *, ctype : typing.Optional[global___FieldOptions.CType.V] = ..., @@ -897,21 +1038,22 @@ class FieldOptions(google.protobuf.message.Message): weak : typing.Optional[builtins.bool] = ..., uninterpreted_option : typing.Optional[typing.Iterable[global___UninterpretedOption]] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"ctype",b"ctype",u"deprecated",b"deprecated",u"jstype",b"jstype",u"lazy",b"lazy",u"packed",b"packed",u"weak",b"weak"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"ctype",b"ctype",u"deprecated",b"deprecated",u"jstype",b"jstype",u"lazy",b"lazy",u"packed",b"packed",u"uninterpreted_option",b"uninterpreted_option",u"weak",b"weak"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["ctype",b"ctype","deprecated",b"deprecated","jstype",b"jstype","lazy",b"lazy","packed",b"packed","weak",b"weak"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["ctype",b"ctype","deprecated",b"deprecated","jstype",b"jstype","lazy",b"lazy","packed",b"packed","uninterpreted_option",b"uninterpreted_option","weak",b"weak"]) -> None: ... global___FieldOptions = FieldOptions class OneofOptions(google.protobuf.message.Message): DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int - # The parser stores options it doesn't recognize here. See above. @property - def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: ... + def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: + """The parser stores options it doesn't recognize here. See above.""" + pass def __init__(self, *, uninterpreted_option : typing.Optional[typing.Iterable[global___UninterpretedOption]] = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["uninterpreted_option",b"uninterpreted_option"]) -> None: ... global___OneofOptions = OneofOptions class EnumOptions(google.protobuf.message.Message): @@ -919,138 +1061,159 @@ class EnumOptions(google.protobuf.message.Message): ALLOW_ALIAS_FIELD_NUMBER: builtins.int DEPRECATED_FIELD_NUMBER: builtins.int UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int - # Set this option to true to allow mapping different tag names to the same - # value. allow_alias: builtins.bool = ... - # Is this enum deprecated? - # Depending on the target platform, this can emit Deprecated annotations - # for the enum, or it will be completely ignored; in the very least, this - # is a formalization for deprecating enums. + """Set this option to true to allow mapping different tag names to the same + value. + """ + deprecated: builtins.bool = ... - # The parser stores options it doesn't recognize here. See above. + """Is this enum deprecated? + Depending on the target platform, this can emit Deprecated annotations + for the enum, or it will be completely ignored; in the very least, this + is a formalization for deprecating enums. + """ + @property - def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: ... + def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: + """The parser stores options it doesn't recognize here. See above.""" + pass def __init__(self, *, allow_alias : typing.Optional[builtins.bool] = ..., deprecated : typing.Optional[builtins.bool] = ..., uninterpreted_option : typing.Optional[typing.Iterable[global___UninterpretedOption]] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"allow_alias",b"allow_alias",u"deprecated",b"deprecated"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"allow_alias",b"allow_alias",u"deprecated",b"deprecated",u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["allow_alias",b"allow_alias","deprecated",b"deprecated"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["allow_alias",b"allow_alias","deprecated",b"deprecated","uninterpreted_option",b"uninterpreted_option"]) -> None: ... global___EnumOptions = EnumOptions class EnumValueOptions(google.protobuf.message.Message): DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... DEPRECATED_FIELD_NUMBER: builtins.int UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int - # Is this enum value deprecated? - # Depending on the target platform, this can emit Deprecated annotations - # for the enum value, or it will be completely ignored; in the very least, - # this is a formalization for deprecating enum values. deprecated: builtins.bool = ... - # The parser stores options it doesn't recognize here. See above. + """Is this enum value deprecated? + Depending on the target platform, this can emit Deprecated annotations + for the enum value, or it will be completely ignored; in the very least, + this is a formalization for deprecating enum values. + """ + @property - def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: ... + def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: + """The parser stores options it doesn't recognize here. See above.""" + pass def __init__(self, *, deprecated : typing.Optional[builtins.bool] = ..., uninterpreted_option : typing.Optional[typing.Iterable[global___UninterpretedOption]] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"deprecated",b"deprecated"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"deprecated",b"deprecated",u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["deprecated",b"deprecated"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["deprecated",b"deprecated","uninterpreted_option",b"uninterpreted_option"]) -> None: ... global___EnumValueOptions = EnumValueOptions class ServiceOptions(google.protobuf.message.Message): DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... DEPRECATED_FIELD_NUMBER: builtins.int UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int - # Note: Field numbers 1 through 32 are reserved for Google's internal RPC - # framework. We apologize for hoarding these numbers to ourselves, but - # we were already using them long before we decided to release Protocol - # Buffers. - - # Is this service deprecated? - # Depending on the target platform, this can emit Deprecated annotations - # for the service, or it will be completely ignored; in the very least, - # this is a formalization for deprecating services. deprecated: builtins.bool = ... - # The parser stores options it doesn't recognize here. See above. + """Note: Field numbers 1 through 32 are reserved for Google's internal RPC + framework. We apologize for hoarding these numbers to ourselves, but + we were already using them long before we decided to release Protocol + Buffers. + + Is this service deprecated? + Depending on the target platform, this can emit Deprecated annotations + for the service, or it will be completely ignored; in the very least, + this is a formalization for deprecating services. + """ + @property - def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: ... + def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: + """The parser stores options it doesn't recognize here. See above.""" + pass def __init__(self, *, deprecated : typing.Optional[builtins.bool] = ..., uninterpreted_option : typing.Optional[typing.Iterable[global___UninterpretedOption]] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"deprecated",b"deprecated"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"deprecated",b"deprecated",u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["deprecated",b"deprecated"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["deprecated",b"deprecated","uninterpreted_option",b"uninterpreted_option"]) -> None: ... global___ServiceOptions = ServiceOptions class MethodOptions(google.protobuf.message.Message): DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... - # Is this method side-effect-free (or safe in HTTP parlance), or idempotent, - # or neither? HTTP based RPC implementation may choose GET verb for safe - # methods, and PUT verb for idempotent methods instead of the default POST. class IdempotencyLevel(_IdempotencyLevel, metaclass=_IdempotencyLevelEnumTypeWrapper): + """Is this method side-effect-free (or safe in HTTP parlance), or idempotent, + or neither? HTTP based RPC implementation may choose GET verb for safe + methods, and PUT verb for idempotent methods instead of the default POST. + """ pass class _IdempotencyLevel: V = typing.NewType('V', builtins.int) class _IdempotencyLevelEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_IdempotencyLevel.V], builtins.type): DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor = ... IDEMPOTENCY_UNKNOWN = MethodOptions.IdempotencyLevel.V(0) - # implies idempotent NO_SIDE_EFFECTS = MethodOptions.IdempotencyLevel.V(1) - # idempotent, but may have side effects + """implies idempotent""" + IDEMPOTENT = MethodOptions.IdempotencyLevel.V(2) + """idempotent, but may have side effects""" + IDEMPOTENCY_UNKNOWN = MethodOptions.IdempotencyLevel.V(0) - # implies idempotent NO_SIDE_EFFECTS = MethodOptions.IdempotencyLevel.V(1) - # idempotent, but may have side effects + """implies idempotent""" + IDEMPOTENT = MethodOptions.IdempotencyLevel.V(2) + """idempotent, but may have side effects""" + DEPRECATED_FIELD_NUMBER: builtins.int IDEMPOTENCY_LEVEL_FIELD_NUMBER: builtins.int UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int - # Note: Field numbers 1 through 32 are reserved for Google's internal RPC - # framework. We apologize for hoarding these numbers to ourselves, but - # we were already using them long before we decided to release Protocol - # Buffers. - - # Is this method deprecated? - # Depending on the target platform, this can emit Deprecated annotations - # for the method, or it will be completely ignored; in the very least, - # this is a formalization for deprecating methods. deprecated: builtins.bool = ... + """Note: Field numbers 1 through 32 are reserved for Google's internal RPC + framework. We apologize for hoarding these numbers to ourselves, but + we were already using them long before we decided to release Protocol + Buffers. + + Is this method deprecated? + Depending on the target platform, this can emit Deprecated annotations + for the method, or it will be completely ignored; in the very least, + this is a formalization for deprecating methods. + """ + idempotency_level: global___MethodOptions.IdempotencyLevel.V = ... - # The parser stores options it doesn't recognize here. See above. @property - def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: ... + def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]: + """The parser stores options it doesn't recognize here. See above.""" + pass def __init__(self, *, deprecated : typing.Optional[builtins.bool] = ..., idempotency_level : typing.Optional[global___MethodOptions.IdempotencyLevel.V] = ..., uninterpreted_option : typing.Optional[typing.Iterable[global___UninterpretedOption]] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"deprecated",b"deprecated",u"idempotency_level",b"idempotency_level"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"deprecated",b"deprecated",u"idempotency_level",b"idempotency_level",u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["deprecated",b"deprecated","idempotency_level",b"idempotency_level"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["deprecated",b"deprecated","idempotency_level",b"idempotency_level","uninterpreted_option",b"uninterpreted_option"]) -> None: ... global___MethodOptions = MethodOptions -# A message representing a option the parser does not recognize. This only -# appears in options protos created by the compiler::Parser class. -# DescriptorPool resolves these when building Descriptor objects. Therefore, -# options protos in descriptor objects (e.g. returned by Descriptor::options(), -# or produced by Descriptor::CopyTo()) will never have UninterpretedOptions -# in them. class UninterpretedOption(google.protobuf.message.Message): + """A message representing a option the parser does not recognize. This only + appears in options protos created by the compiler::Parser class. + DescriptorPool resolves these when building Descriptor objects. Therefore, + options protos in descriptor objects (e.g. returned by Descriptor::options(), + or produced by Descriptor::CopyTo()) will never have UninterpretedOptions + in them. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... - # The name of the uninterpreted option. Each string represents a segment in - # a dot-separated name. is_extension is true iff a segment represents an - # extension (denoted with parentheses in options specs in .proto files). - # E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents - # "foo.(bar.baz).qux". class NamePart(google.protobuf.message.Message): + """The name of the uninterpreted option. Each string represents a segment in + a dot-separated name. is_extension is true iff a segment represents an + extension (denoted with parentheses in options specs in .proto files). + E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents + "foo.(bar.baz).qux". + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_PART_FIELD_NUMBER: builtins.int IS_EXTENSION_FIELD_NUMBER: builtins.int @@ -1061,8 +1224,8 @@ class UninterpretedOption(google.protobuf.message.Message): name_part : typing.Optional[typing.Text] = ..., is_extension : typing.Optional[builtins.bool] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"is_extension",b"is_extension",u"name_part",b"name_part"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"is_extension",b"is_extension",u"name_part",b"name_part"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["is_extension",b"is_extension","name_part",b"name_part"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["is_extension",b"is_extension","name_part",b"name_part"]) -> None: ... NAME_FIELD_NUMBER: builtins.int IDENTIFIER_VALUE_FIELD_NUMBER: builtins.int @@ -1073,9 +1236,11 @@ class UninterpretedOption(google.protobuf.message.Message): AGGREGATE_VALUE_FIELD_NUMBER: builtins.int @property def name(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption.NamePart]: ... - # The value of the uninterpreted option, in whatever type the tokenizer - # identified it as during parsing. Exactly one of these should be set. identifier_value: typing.Text = ... + """The value of the uninterpreted option, in whatever type the tokenizer + identified it as during parsing. Exactly one of these should be set. + """ + positive_int_value: builtins.int = ... negative_int_value: builtins.int = ... double_value: builtins.float = ... @@ -1091,16 +1256,17 @@ class UninterpretedOption(google.protobuf.message.Message): string_value : typing.Optional[builtins.bytes] = ..., aggregate_value : typing.Optional[typing.Text] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"aggregate_value",b"aggregate_value",u"double_value",b"double_value",u"identifier_value",b"identifier_value",u"negative_int_value",b"negative_int_value",u"positive_int_value",b"positive_int_value",u"string_value",b"string_value"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"aggregate_value",b"aggregate_value",u"double_value",b"double_value",u"identifier_value",b"identifier_value",u"name",b"name",u"negative_int_value",b"negative_int_value",u"positive_int_value",b"positive_int_value",u"string_value",b"string_value"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["aggregate_value",b"aggregate_value","double_value",b"double_value","identifier_value",b"identifier_value","negative_int_value",b"negative_int_value","positive_int_value",b"positive_int_value","string_value",b"string_value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["aggregate_value",b"aggregate_value","double_value",b"double_value","identifier_value",b"identifier_value","name",b"name","negative_int_value",b"negative_int_value","positive_int_value",b"positive_int_value","string_value",b"string_value"]) -> None: ... global___UninterpretedOption = UninterpretedOption -# =================================================================== -# Optional source code info - -# Encapsulates information about the original source file from which a -# FileDescriptorProto was generated. class SourceCodeInfo(google.protobuf.message.Message): + """=================================================================== + Optional source code info + + Encapsulates information about the original source file from which a + FileDescriptorProto was generated. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... class Location(google.protobuf.message.Message): DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... @@ -1109,86 +1275,92 @@ class SourceCodeInfo(google.protobuf.message.Message): LEADING_COMMENTS_FIELD_NUMBER: builtins.int TRAILING_COMMENTS_FIELD_NUMBER: builtins.int LEADING_DETACHED_COMMENTS_FIELD_NUMBER: builtins.int - # Identifies which part of the FileDescriptorProto was defined at this - # location. - # - # Each element is a field number or an index. They form a path from - # the root FileDescriptorProto to the place where the definition. For - # example, this path: - # [ 4, 3, 2, 7, 1 ] - # refers to: - # file.message_type(3) // 4, 3 - # .field(7) // 2, 7 - # .name() // 1 - # This is because FileDescriptorProto.message_type has field number 4: - # repeated DescriptorProto message_type = 4; - # and DescriptorProto.field has field number 2: - # repeated FieldDescriptorProto field = 2; - # and FieldDescriptorProto.name has field number 1: - # optional string name = 1; - # - # Thus, the above path gives the location of a field name. If we removed - # the last element: - # [ 4, 3, 2, 7 ] - # this path refers to the whole field declaration (from the beginning - # of the label to the terminating semicolon). @property - def path(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: ... - # Always has exactly three or four elements: start line, start column, - # end line (optional, otherwise assumed same as start line), end column. - # These are packed into a single field for efficiency. Note that line - # and column numbers are zero-based -- typically you will want to add - # 1 to each before displaying to a user. + def path(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: + """Identifies which part of the FileDescriptorProto was defined at this + location. + + Each element is a field number or an index. They form a path from + the root FileDescriptorProto to the place where the definition. For + example, this path: + [ 4, 3, 2, 7, 1 ] + refers to: + file.message_type(3) // 4, 3 + .field(7) // 2, 7 + .name() // 1 + This is because FileDescriptorProto.message_type has field number 4: + repeated DescriptorProto message_type = 4; + and DescriptorProto.field has field number 2: + repeated FieldDescriptorProto field = 2; + and FieldDescriptorProto.name has field number 1: + optional string name = 1; + + Thus, the above path gives the location of a field name. If we removed + the last element: + [ 4, 3, 2, 7 ] + this path refers to the whole field declaration (from the beginning + of the label to the terminating semicolon). + """ + pass @property - def span(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: ... - # If this SourceCodeInfo represents a complete declaration, these are any - # comments appearing before and after the declaration which appear to be - # attached to the declaration. - # - # A series of line comments appearing on consecutive lines, with no other - # tokens appearing on those lines, will be treated as a single comment. - # - # leading_detached_comments will keep paragraphs of comments that appear - # before (but not connected to) the current element. Each paragraph, - # separated by empty lines, will be one comment element in the repeated - # field. - # - # Only the comment content is provided; comment markers (e.g. //) are - # stripped out. For block comments, leading whitespace and an asterisk - # will be stripped from the beginning of each line other than the first. - # Newlines are included in the output. - # - # Examples: - # - # optional int32 foo = 1; // Comment attached to foo. - # // Comment attached to bar. - # optional int32 bar = 2; - # - # optional string baz = 3; - # // Comment attached to baz. - # // Another line attached to baz. - # - # // Comment attached to qux. - # // - # // Another line attached to qux. - # optional double qux = 4; - # - # // Detached comment for corge. This is not leading or trailing comments - # // to qux or corge because there are blank lines separating it from - # // both. - # - # // Detached comment for corge paragraph 2. - # - # optional string corge = 5; - # /* Block comment attached - # * to corge. Leading asterisks - # * will be removed. */ - # /* Block comment attached to - # * grault. */ - # optional int32 grault = 6; - # - # // ignored detached comments. + def span(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: + """Always has exactly three or four elements: start line, start column, + end line (optional, otherwise assumed same as start line), end column. + These are packed into a single field for efficiency. Note that line + and column numbers are zero-based -- typically you will want to add + 1 to each before displaying to a user. + """ + pass leading_comments: typing.Text = ... + """If this SourceCodeInfo represents a complete declaration, these are any + comments appearing before and after the declaration which appear to be + attached to the declaration. + + A series of line comments appearing on consecutive lines, with no other + tokens appearing on those lines, will be treated as a single comment. + + leading_detached_comments will keep paragraphs of comments that appear + before (but not connected to) the current element. Each paragraph, + separated by empty lines, will be one comment element in the repeated + field. + + Only the comment content is provided; comment markers (e.g. //) are + stripped out. For block comments, leading whitespace and an asterisk + will be stripped from the beginning of each line other than the first. + Newlines are included in the output. + + Examples: + + optional int32 foo = 1; // Comment attached to foo. + // Comment attached to bar. + optional int32 bar = 2; + + optional string baz = 3; + // Comment attached to baz. + // Another line attached to baz. + + // Comment attached to qux. + // + // Another line attached to qux. + optional double qux = 4; + + // Detached comment for corge. This is not leading or trailing comments + // to qux or corge because there are blank lines separating it from + // both. + + // Detached comment for corge paragraph 2. + + optional string corge = 5; + /* Block comment attached + * to corge. Leading asterisks + * will be removed. */ + /* Block comment attached to + * grault. */ + optional int32 grault = 6; + + // ignored detached comments. + """ + trailing_comments: typing.Text = ... @property def leading_detached_comments(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]: ... @@ -1200,66 +1372,69 @@ class SourceCodeInfo(google.protobuf.message.Message): trailing_comments : typing.Optional[typing.Text] = ..., leading_detached_comments : typing.Optional[typing.Iterable[typing.Text]] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"leading_comments",b"leading_comments",u"trailing_comments",b"trailing_comments"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"leading_comments",b"leading_comments",u"leading_detached_comments",b"leading_detached_comments",u"path",b"path",u"span",b"span",u"trailing_comments",b"trailing_comments"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["leading_comments",b"leading_comments","trailing_comments",b"trailing_comments"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["leading_comments",b"leading_comments","leading_detached_comments",b"leading_detached_comments","path",b"path","span",b"span","trailing_comments",b"trailing_comments"]) -> None: ... LOCATION_FIELD_NUMBER: builtins.int - # A Location identifies a piece of source code in a .proto file which - # corresponds to a particular definition. This information is intended - # to be useful to IDEs, code indexers, documentation generators, and similar - # tools. - # - # For example, say we have a file like: - # message Foo { - # optional string foo = 1; - # } - # Let's look at just the field definition: - # optional string foo = 1; - # ^ ^^ ^^ ^ ^^^ - # a bc de f ghi - # We have the following locations: - # span path represents - # [a,i) [ 4, 0, 2, 0 ] The whole field definition. - # [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). - # [c,d) [ 4, 0, 2, 0, 5 ] The type (string). - # [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). - # [g,h) [ 4, 0, 2, 0, 3 ] The number (1). - # - # Notes: - # - A location may refer to a repeated field itself (i.e. not to any - # particular index within it). This is used whenever a set of elements are - # logically enclosed in a single code segment. For example, an entire - # extend block (possibly containing multiple extension definitions) will - # have an outer location whose path refers to the "extensions" repeated - # field without an index. - # - Multiple locations may have the same path. This happens when a single - # logical declaration is spread out across multiple places. The most - # obvious example is the "extend" block again -- there may be multiple - # extend blocks in the same scope, each of which will have the same path. - # - A location's span is not always a subset of its parent's span. For - # example, the "extendee" of an extension declaration appears at the - # beginning of the "extend" block and is shared by all extensions within - # the block. - # - Just because a location's span is a subset of some other location's span - # does not mean that it is a descendant. For example, a "group" defines - # both a type and a field in a single declaration. Thus, the locations - # corresponding to the type and field and their components will overlap. - # - Code which tries to interpret locations should probably be designed to - # ignore those that it doesn't understand, as more types of locations could - # be recorded in the future. @property - def location(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___SourceCodeInfo.Location]: ... + def location(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___SourceCodeInfo.Location]: + """A Location identifies a piece of source code in a .proto file which + corresponds to a particular definition. This information is intended + to be useful to IDEs, code indexers, documentation generators, and similar + tools. + + For example, say we have a file like: + message Foo { + optional string foo = 1; + } + Let's look at just the field definition: + optional string foo = 1; + ^ ^^ ^^ ^ ^^^ + a bc de f ghi + We have the following locations: + span path represents + [a,i) [ 4, 0, 2, 0 ] The whole field definition. + [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + + Notes: + - A location may refer to a repeated field itself (i.e. not to any + particular index within it). This is used whenever a set of elements are + logically enclosed in a single code segment. For example, an entire + extend block (possibly containing multiple extension definitions) will + have an outer location whose path refers to the "extensions" repeated + field without an index. + - Multiple locations may have the same path. This happens when a single + logical declaration is spread out across multiple places. The most + obvious example is the "extend" block again -- there may be multiple + extend blocks in the same scope, each of which will have the same path. + - A location's span is not always a subset of its parent's span. For + example, the "extendee" of an extension declaration appears at the + beginning of the "extend" block and is shared by all extensions within + the block. + - Just because a location's span is a subset of some other location's span + does not mean that it is a descendant. For example, a "group" defines + both a type and a field in a single declaration. Thus, the locations + corresponding to the type and field and their components will overlap. + - Code which tries to interpret locations should probably be designed to + ignore those that it doesn't understand, as more types of locations could + be recorded in the future. + """ + pass def __init__(self, *, location : typing.Optional[typing.Iterable[global___SourceCodeInfo.Location]] = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"location",b"location"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["location",b"location"]) -> None: ... global___SourceCodeInfo = SourceCodeInfo -# Describes the relationship between generated code and its original source -# file. A GeneratedCodeInfo message is associated with only one generated -# source file, but may contain references to different source .proto files. class GeneratedCodeInfo(google.protobuf.message.Message): + """Describes the relationship between generated code and its original source + file. A GeneratedCodeInfo message is associated with only one generated + source file, but may contain references to different source .proto files. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... class Annotation(google.protobuf.message.Message): DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... @@ -1267,19 +1442,26 @@ class GeneratedCodeInfo(google.protobuf.message.Message): SOURCE_FILE_FIELD_NUMBER: builtins.int BEGIN_FIELD_NUMBER: builtins.int END_FIELD_NUMBER: builtins.int - # Identifies the element in the original source .proto file. This field - # is formatted the same as SourceCodeInfo.Location.path. @property - def path(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: ... - # Identifies the filesystem path to the original source .proto. + def path(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: + """Identifies the element in the original source .proto file. This field + is formatted the same as SourceCodeInfo.Location.path. + """ + pass source_file: typing.Text = ... - # Identifies the starting offset in bytes in the generated code - # that relates to the identified object. + """Identifies the filesystem path to the original source .proto.""" + begin: builtins.int = ... - # Identifies the ending offset in bytes in the generated code that - # relates to the identified offset. The end offset should be one past - # the last relevant byte (so the length of the text = end - begin). + """Identifies the starting offset in bytes in the generated code + that relates to the identified object. + """ + end: builtins.int = ... + """Identifies the ending offset in bytes in the generated code that + relates to the identified offset. The end offset should be one past + the last relevant byte (so the length of the text = end - begin). + """ + def __init__(self, *, path : typing.Optional[typing.Iterable[builtins.int]] = ..., @@ -1287,17 +1469,19 @@ class GeneratedCodeInfo(google.protobuf.message.Message): begin : typing.Optional[builtins.int] = ..., end : typing.Optional[builtins.int] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"begin",b"begin",u"end",b"end",u"source_file",b"source_file"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"begin",b"begin",u"end",b"end",u"path",b"path",u"source_file",b"source_file"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["begin",b"begin","end",b"end","source_file",b"source_file"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["begin",b"begin","end",b"end","path",b"path","source_file",b"source_file"]) -> None: ... ANNOTATION_FIELD_NUMBER: builtins.int - # An Annotation connects some span of text in generated code to an element - # of its generating .proto file. @property - def annotation(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___GeneratedCodeInfo.Annotation]: ... + def annotation(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___GeneratedCodeInfo.Annotation]: + """An Annotation connects some span of text in generated code to an element + of its generating .proto file. + """ + pass def __init__(self, *, annotation : typing.Optional[typing.Iterable[global___GeneratedCodeInfo.Annotation]] = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"annotation",b"annotation"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["annotation",b"annotation"]) -> None: ... global___GeneratedCodeInfo = GeneratedCodeInfo diff --git a/stubs/protobuf/google/protobuf/duration_pb2.pyi b/stubs/protobuf/google/protobuf/duration_pb2.pyi index c5773fdf8..b2786a8ed 100644 --- a/stubs/protobuf/google/protobuf/duration_pb2.pyi +++ b/stubs/protobuf/google/protobuf/duration_pb2.pyi @@ -10,83 +10,88 @@ import typing_extensions DESCRIPTOR: google.protobuf.descriptor.FileDescriptor = ... -# A Duration represents a signed, fixed-length span of time represented -# as a count of seconds and fractions of seconds at nanosecond -# resolution. It is independent of any calendar and concepts like "day" -# or "month". It is related to Timestamp in that the difference between -# two Timestamp values is a Duration and it can be added or subtracted -# from a Timestamp. Range is approximately +-10,000 years. -# -# # Examples -# -# Example 1: Compute Duration from two Timestamps in pseudo code. -# -# Timestamp start = ...; -# Timestamp end = ...; -# Duration duration = ...; -# -# duration.seconds = end.seconds - start.seconds; -# duration.nanos = end.nanos - start.nanos; -# -# if (duration.seconds < 0 && duration.nanos > 0) { -# duration.seconds += 1; -# duration.nanos -= 1000000000; -# } else if (duration.seconds > 0 && duration.nanos < 0) { -# duration.seconds -= 1; -# duration.nanos += 1000000000; -# } -# -# Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. -# -# Timestamp start = ...; -# Duration duration = ...; -# Timestamp end = ...; -# -# end.seconds = start.seconds + duration.seconds; -# end.nanos = start.nanos + duration.nanos; -# -# if (end.nanos < 0) { -# end.seconds -= 1; -# end.nanos += 1000000000; -# } else if (end.nanos >= 1000000000) { -# end.seconds += 1; -# end.nanos -= 1000000000; -# } -# -# Example 3: Compute Duration from datetime.timedelta in Python. -# -# td = datetime.timedelta(days=3, minutes=10) -# duration = Duration() -# duration.FromTimedelta(td) -# -# # JSON Mapping -# -# In JSON format, the Duration type is encoded as a string rather than an -# object, where the string ends in the suffix "s" (indicating seconds) and -# is preceded by the number of seconds, with nanoseconds expressed as -# fractional seconds. For example, 3 seconds with 0 nanoseconds should be -# encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should -# be expressed in JSON format as "3.000000001s", and 3 seconds and 1 -# microsecond should be expressed in JSON format as "3.000001s". class Duration(google.protobuf.message.Message, google.protobuf.internal.well_known_types.Duration): + """A Duration represents a signed, fixed-length span of time represented + as a count of seconds and fractions of seconds at nanosecond + resolution. It is independent of any calendar and concepts like "day" + or "month". It is related to Timestamp in that the difference between + two Timestamp values is a Duration and it can be added or subtracted + from a Timestamp. Range is approximately +-10,000 years. + + # Examples + + Example 1: Compute Duration from two Timestamps in pseudo code. + + Timestamp start = ...; + Timestamp end = ...; + Duration duration = ...; + + duration.seconds = end.seconds - start.seconds; + duration.nanos = end.nanos - start.nanos; + + if (duration.seconds < 0 && duration.nanos > 0) { + duration.seconds += 1; + duration.nanos -= 1000000000; + } else if (duration.seconds > 0 && duration.nanos < 0) { + duration.seconds -= 1; + duration.nanos += 1000000000; + } + + Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. + + Timestamp start = ...; + Duration duration = ...; + Timestamp end = ...; + + end.seconds = start.seconds + duration.seconds; + end.nanos = start.nanos + duration.nanos; + + if (end.nanos < 0) { + end.seconds -= 1; + end.nanos += 1000000000; + } else if (end.nanos >= 1000000000) { + end.seconds += 1; + end.nanos -= 1000000000; + } + + Example 3: Compute Duration from datetime.timedelta in Python. + + td = datetime.timedelta(days=3, minutes=10) + duration = Duration() + duration.FromTimedelta(td) + + # JSON Mapping + + In JSON format, the Duration type is encoded as a string rather than an + object, where the string ends in the suffix "s" (indicating seconds) and + is preceded by the number of seconds, with nanoseconds expressed as + fractional seconds. For example, 3 seconds with 0 nanoseconds should be + encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should + be expressed in JSON format as "3.000000001s", and 3 seconds and 1 + microsecond should be expressed in JSON format as "3.000001s". + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... SECONDS_FIELD_NUMBER: builtins.int NANOS_FIELD_NUMBER: builtins.int - # Signed seconds of the span of time. Must be from -315,576,000,000 - # to +315,576,000,000 inclusive. Note: these bounds are computed from: - # 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years seconds: builtins.int = ... - # Signed fractions of a second at nanosecond resolution of the span - # of time. Durations less than one second are represented with a 0 - # `seconds` field and a positive or negative `nanos` field. For durations - # of one second or more, a non-zero value for the `nanos` field must be - # of the same sign as the `seconds` field. Must be from -999,999,999 - # to +999,999,999 inclusive. + """Signed seconds of the span of time. Must be from -315,576,000,000 + to +315,576,000,000 inclusive. Note: these bounds are computed from: + 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years + """ + nanos: builtins.int = ... + """Signed fractions of a second at nanosecond resolution of the span + of time. Durations less than one second are represented with a 0 + `seconds` field and a positive or negative `nanos` field. For durations + of one second or more, a non-zero value for the `nanos` field must be + of the same sign as the `seconds` field. Must be from -999,999,999 + to +999,999,999 inclusive. + """ + def __init__(self, *, seconds : builtins.int = ..., nanos : builtins.int = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"nanos",b"nanos",u"seconds",b"seconds"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["nanos",b"nanos","seconds",b"seconds"]) -> None: ... global___Duration = Duration diff --git a/stubs/protobuf/google/protobuf/empty_pb2.pyi b/stubs/protobuf/google/protobuf/empty_pb2.pyi index 1d916e9f7..333e26158 100644 --- a/stubs/protobuf/google/protobuf/empty_pb2.pyi +++ b/stubs/protobuf/google/protobuf/empty_pb2.pyi @@ -7,16 +7,17 @@ import google.protobuf.message DESCRIPTOR: google.protobuf.descriptor.FileDescriptor = ... -# A generic empty message that you can re-use to avoid defining duplicated -# empty messages in your APIs. A typical example is to use it as the request -# or the response type of an API method. For instance: -# -# service Foo { -# rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); -# } -# -# The JSON representation for `Empty` is empty JSON object `{}`. class Empty(google.protobuf.message.Message): + """A generic empty message that you can re-use to avoid defining duplicated + empty messages in your APIs. A typical example is to use it as the request + or the response type of an API method. For instance: + + service Foo { + rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); + } + + The JSON representation for `Empty` is empty JSON object `{}`. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... def __init__(self, ) -> None: ... diff --git a/stubs/protobuf/google/protobuf/field_mask_pb2.pyi b/stubs/protobuf/google/protobuf/field_mask_pb2.pyi index efa622a68..fba06afd7 100644 --- a/stubs/protobuf/google/protobuf/field_mask_pb2.pyi +++ b/stubs/protobuf/google/protobuf/field_mask_pb2.pyi @@ -12,214 +12,216 @@ import typing_extensions DESCRIPTOR: google.protobuf.descriptor.FileDescriptor = ... -# `FieldMask` represents a set of symbolic field paths, for example: -# -# paths: "f.a" -# paths: "f.b.d" -# -# Here `f` represents a field in some root message, `a` and `b` -# fields in the message found in `f`, and `d` a field found in the -# message in `f.b`. -# -# Field masks are used to specify a subset of fields that should be -# returned by a get operation or modified by an update operation. -# Field masks also have a custom JSON encoding (see below). -# -# # Field Masks in Projections -# -# When used in the context of a projection, a response message or -# sub-message is filtered by the API to only contain those fields as -# specified in the mask. For example, if the mask in the previous -# example is applied to a response message as follows: -# -# f { -# a : 22 -# b { -# d : 1 -# x : 2 -# } -# y : 13 -# } -# z: 8 -# -# The result will not contain specific values for fields x,y and z -# (their value will be set to the default, and omitted in proto text -# output): -# -# -# f { -# a : 22 -# b { -# d : 1 -# } -# } -# -# A repeated field is not allowed except at the last position of a -# paths string. -# -# If a FieldMask object is not present in a get operation, the -# operation applies to all fields (as if a FieldMask of all fields -# had been specified). -# -# Note that a field mask does not necessarily apply to the -# top-level response message. In case of a REST get operation, the -# field mask applies directly to the response, but in case of a REST -# list operation, the mask instead applies to each individual message -# in the returned resource list. In case of a REST custom method, -# other definitions may be used. Where the mask applies will be -# clearly documented together with its declaration in the API. In -# any case, the effect on the returned resource/resources is required -# behavior for APIs. -# -# # Field Masks in Update Operations -# -# A field mask in update operations specifies which fields of the -# targeted resource are going to be updated. The API is required -# to only change the values of the fields as specified in the mask -# and leave the others untouched. If a resource is passed in to -# describe the updated values, the API ignores the values of all -# fields not covered by the mask. -# -# If a repeated field is specified for an update operation, new values will -# be appended to the existing repeated field in the target resource. Note that -# a repeated field is only allowed in the last position of a `paths` string. -# -# If a sub-message is specified in the last position of the field mask for an -# update operation, then new value will be merged into the existing sub-message -# in the target resource. -# -# For example, given the target message: -# -# f { -# b { -# d: 1 -# x: 2 -# } -# c: [1] -# } -# -# And an update message: -# -# f { -# b { -# d: 10 -# } -# c: [2] -# } -# -# then if the field mask is: -# -# paths: ["f.b", "f.c"] -# -# then the result will be: -# -# f { -# b { -# d: 10 -# x: 2 -# } -# c: [1, 2] -# } -# -# An implementation may provide options to override this default behavior for -# repeated and message fields. -# -# In order to reset a field's value to the default, the field must -# be in the mask and set to the default value in the provided resource. -# Hence, in order to reset all fields of a resource, provide a default -# instance of the resource and set all fields in the mask, or do -# not provide a mask as described below. -# -# If a field mask is not present on update, the operation applies to -# all fields (as if a field mask of all fields has been specified). -# Note that in the presence of schema evolution, this may mean that -# fields the client does not know and has therefore not filled into -# the request will be reset to their default. If this is unwanted -# behavior, a specific service may require a client to always specify -# a field mask, producing an error if not. -# -# As with get operations, the location of the resource which -# describes the updated values in the request message depends on the -# operation kind. In any case, the effect of the field mask is -# required to be honored by the API. -# -# ## Considerations for HTTP REST -# -# The HTTP kind of an update operation which uses a field mask must -# be set to PATCH instead of PUT in order to satisfy HTTP semantics -# (PUT must only be used for full updates). -# -# # JSON Encoding of Field Masks -# -# In JSON, a field mask is encoded as a single string where paths are -# separated by a comma. Fields name in each path are converted -# to/from lower-camel naming conventions. -# -# As an example, consider the following message declarations: -# -# message Profile { -# User user = 1; -# Photo photo = 2; -# } -# message User { -# string display_name = 1; -# string address = 2; -# } -# -# In proto a field mask for `Profile` may look as such: -# -# mask { -# paths: "user.display_name" -# paths: "photo" -# } -# -# In JSON, the same mask is represented as below: -# -# { -# mask: "user.displayName,photo" -# } -# -# # Field Masks and Oneof Fields -# -# Field masks treat fields in oneofs just as regular fields. Consider the -# following message: -# -# message SampleMessage { -# oneof test_oneof { -# string name = 4; -# SubMessage sub_message = 9; -# } -# } -# -# The field mask can be: -# -# mask { -# paths: "name" -# } -# -# Or: -# -# mask { -# paths: "sub_message" -# } -# -# Note that oneof type names ("test_oneof" in this case) cannot be used in -# paths. -# -# ## Field Mask Verification -# -# The implementation of any API method which has a FieldMask type field in the -# request should verify the included field paths, and return an -# `INVALID_ARGUMENT` error if any path is unmappable. class FieldMask(google.protobuf.message.Message, google.protobuf.internal.well_known_types.FieldMask): + """`FieldMask` represents a set of symbolic field paths, for example: + + paths: "f.a" + paths: "f.b.d" + + Here `f` represents a field in some root message, `a` and `b` + fields in the message found in `f`, and `d` a field found in the + message in `f.b`. + + Field masks are used to specify a subset of fields that should be + returned by a get operation or modified by an update operation. + Field masks also have a custom JSON encoding (see below). + + # Field Masks in Projections + + When used in the context of a projection, a response message or + sub-message is filtered by the API to only contain those fields as + specified in the mask. For example, if the mask in the previous + example is applied to a response message as follows: + + f { + a : 22 + b { + d : 1 + x : 2 + } + y : 13 + } + z: 8 + + The result will not contain specific values for fields x,y and z + (their value will be set to the default, and omitted in proto text + output): + + + f { + a : 22 + b { + d : 1 + } + } + + A repeated field is not allowed except at the last position of a + paths string. + + If a FieldMask object is not present in a get operation, the + operation applies to all fields (as if a FieldMask of all fields + had been specified). + + Note that a field mask does not necessarily apply to the + top-level response message. In case of a REST get operation, the + field mask applies directly to the response, but in case of a REST + list operation, the mask instead applies to each individual message + in the returned resource list. In case of a REST custom method, + other definitions may be used. Where the mask applies will be + clearly documented together with its declaration in the API. In + any case, the effect on the returned resource/resources is required + behavior for APIs. + + # Field Masks in Update Operations + + A field mask in update operations specifies which fields of the + targeted resource are going to be updated. The API is required + to only change the values of the fields as specified in the mask + and leave the others untouched. If a resource is passed in to + describe the updated values, the API ignores the values of all + fields not covered by the mask. + + If a repeated field is specified for an update operation, new values will + be appended to the existing repeated field in the target resource. Note that + a repeated field is only allowed in the last position of a `paths` string. + + If a sub-message is specified in the last position of the field mask for an + update operation, then new value will be merged into the existing sub-message + in the target resource. + + For example, given the target message: + + f { + b { + d: 1 + x: 2 + } + c: [1] + } + + And an update message: + + f { + b { + d: 10 + } + c: [2] + } + + then if the field mask is: + + paths: ["f.b", "f.c"] + + then the result will be: + + f { + b { + d: 10 + x: 2 + } + c: [1, 2] + } + + An implementation may provide options to override this default behavior for + repeated and message fields. + + In order to reset a field's value to the default, the field must + be in the mask and set to the default value in the provided resource. + Hence, in order to reset all fields of a resource, provide a default + instance of the resource and set all fields in the mask, or do + not provide a mask as described below. + + If a field mask is not present on update, the operation applies to + all fields (as if a field mask of all fields has been specified). + Note that in the presence of schema evolution, this may mean that + fields the client does not know and has therefore not filled into + the request will be reset to their default. If this is unwanted + behavior, a specific service may require a client to always specify + a field mask, producing an error if not. + + As with get operations, the location of the resource which + describes the updated values in the request message depends on the + operation kind. In any case, the effect of the field mask is + required to be honored by the API. + + ## Considerations for HTTP REST + + The HTTP kind of an update operation which uses a field mask must + be set to PATCH instead of PUT in order to satisfy HTTP semantics + (PUT must only be used for full updates). + + # JSON Encoding of Field Masks + + In JSON, a field mask is encoded as a single string where paths are + separated by a comma. Fields name in each path are converted + to/from lower-camel naming conventions. + + As an example, consider the following message declarations: + + message Profile { + User user = 1; + Photo photo = 2; + } + message User { + string display_name = 1; + string address = 2; + } + + In proto a field mask for `Profile` may look as such: + + mask { + paths: "user.display_name" + paths: "photo" + } + + In JSON, the same mask is represented as below: + + { + mask: "user.displayName,photo" + } + + # Field Masks and Oneof Fields + + Field masks treat fields in oneofs just as regular fields. Consider the + following message: + + message SampleMessage { + oneof test_oneof { + string name = 4; + SubMessage sub_message = 9; + } + } + + The field mask can be: + + mask { + paths: "name" + } + + Or: + + mask { + paths: "sub_message" + } + + Note that oneof type names ("test_oneof" in this case) cannot be used in + paths. + + ## Field Mask Verification + + The implementation of any API method which has a FieldMask type field in the + request should verify the included field paths, and return an + `INVALID_ARGUMENT` error if any path is unmappable. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... PATHS_FIELD_NUMBER: builtins.int - # The set of field mask paths. @property - def paths(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]: ... + def paths(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]: + """The set of field mask paths.""" + pass def __init__(self, *, paths : typing.Optional[typing.Iterable[typing.Text]] = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"paths",b"paths"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["paths",b"paths"]) -> None: ... global___FieldMask = FieldMask diff --git a/stubs/protobuf/google/protobuf/source_context_pb2.pyi b/stubs/protobuf/google/protobuf/source_context_pb2.pyi index 07e1a4cf3..61c2e83e3 100644 --- a/stubs/protobuf/google/protobuf/source_context_pb2.pyi +++ b/stubs/protobuf/google/protobuf/source_context_pb2.pyi @@ -10,17 +10,20 @@ import typing_extensions DESCRIPTOR: google.protobuf.descriptor.FileDescriptor = ... -# `SourceContext` represents information about the source of a -# protobuf element, like the file in which it is defined. class SourceContext(google.protobuf.message.Message): + """`SourceContext` represents information about the source of a + protobuf element, like the file in which it is defined. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... FILE_NAME_FIELD_NUMBER: builtins.int - # The path-qualified name of the .proto file that contained the associated - # protobuf element. For example: `"google/protobuf/source_context.proto"`. file_name: typing.Text = ... + """The path-qualified name of the .proto file that contained the associated + protobuf element. For example: `"google/protobuf/source_context.proto"`. + """ + def __init__(self, *, file_name : typing.Text = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"file_name",b"file_name"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["file_name",b"file_name"]) -> None: ... global___SourceContext = SourceContext diff --git a/stubs/protobuf/google/protobuf/struct_pb2.pyi b/stubs/protobuf/google/protobuf/struct_pb2.pyi index d6f93a3d1..54e8df72a 100644 --- a/stubs/protobuf/google/protobuf/struct_pb2.pyi +++ b/stubs/protobuf/google/protobuf/struct_pb2.pyi @@ -13,33 +13,37 @@ import typing_extensions DESCRIPTOR: google.protobuf.descriptor.FileDescriptor = ... -# `NullValue` is a singleton enumeration to represent the null value for the -# `Value` type union. -# -# The JSON representation for `NullValue` is JSON `null`. class NullValue(_NullValue, metaclass=_NullValueEnumTypeWrapper): + """`NullValue` is a singleton enumeration to represent the null value for the + `Value` type union. + + The JSON representation for `NullValue` is JSON `null`. + """ pass class _NullValue: V = typing.NewType('V', builtins.int) class _NullValueEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_NullValue.V], builtins.type): DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor = ... - # Null value. NULL_VALUE = NullValue.V(0) + """Null value.""" + -# Null value. NULL_VALUE = NullValue.V(0) +"""Null value.""" + global___NullValue = NullValue -# `Struct` represents a structured data value, consisting of fields -# which map to dynamically typed values. In some languages, `Struct` -# might be supported by a native representation. For example, in -# scripting languages like JS a struct is represented as an -# object. The details of that representation are described together -# with the proto support for the language. -# -# The JSON representation for `Struct` is JSON object. class Struct(google.protobuf.message.Message, google.protobuf.internal.well_known_types.Struct): + """`Struct` represents a structured data value, consisting of fields + which map to dynamically typed values. In some languages, `Struct` + might be supported by a native representation. For example, in + scripting languages like JS a struct is represented as an + object. The details of that representation are described together + with the proto support for the language. + + The JSON representation for `Struct` is JSON object. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... class FieldsEntry(google.protobuf.message.Message): DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... @@ -53,27 +57,29 @@ class Struct(google.protobuf.message.Message, google.protobuf.internal.well_know key : typing.Text = ..., value : typing.Optional[global___Value] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"value",b"value"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"key",b"key",u"value",b"value"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["value",b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["key",b"key","value",b"value"]) -> None: ... FIELDS_FIELD_NUMBER: builtins.int - # Unordered map of dynamically typed values. @property - def fields(self) -> google.protobuf.internal.containers.MessageMap[typing.Text, global___Value]: ... + def fields(self) -> google.protobuf.internal.containers.MessageMap[typing.Text, global___Value]: + """Unordered map of dynamically typed values.""" + pass def __init__(self, *, fields : typing.Optional[typing.Mapping[typing.Text, global___Value]] = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"fields",b"fields"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["fields",b"fields"]) -> None: ... global___Struct = Struct -# `Value` represents a dynamically typed value which can be either -# null, a number, a string, a boolean, a recursive struct value, or a -# list of values. A producer of value is expected to set one of that -# variants, absence of any variant indicates an error. -# -# The JSON representation for `Value` is JSON value. class Value(google.protobuf.message.Message): + """`Value` represents a dynamically typed value which can be either + null, a number, a string, a boolean, a recursive struct value, or a + list of values. A producer of value is expected to set one of that + variants, absence of any variant indicates an error. + + The JSON representation for `Value` is JSON value. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NULL_VALUE_FIELD_NUMBER: builtins.int NUMBER_VALUE_FIELD_NUMBER: builtins.int @@ -81,20 +87,26 @@ class Value(google.protobuf.message.Message): BOOL_VALUE_FIELD_NUMBER: builtins.int STRUCT_VALUE_FIELD_NUMBER: builtins.int LIST_VALUE_FIELD_NUMBER: builtins.int - # Represents a null value. null_value: global___NullValue.V = ... - # Represents a double value. + """Represents a null value.""" + number_value: builtins.float = ... - # Represents a string value. + """Represents a double value.""" + string_value: typing.Text = ... - # Represents a boolean value. + """Represents a string value.""" + bool_value: builtins.bool = ... - # Represents a structured value. + """Represents a boolean value.""" + @property - def struct_value(self) -> global___Struct: ... - # Represents a repeated `Value`. + def struct_value(self) -> global___Struct: + """Represents a structured value.""" + pass @property - def list_value(self) -> global___ListValue: ... + def list_value(self) -> global___ListValue: + """Represents a repeated `Value`.""" + pass def __init__(self, *, null_value : global___NullValue.V = ..., @@ -104,23 +116,25 @@ class Value(google.protobuf.message.Message): struct_value : typing.Optional[global___Struct] = ..., list_value : typing.Optional[global___ListValue] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"bool_value",b"bool_value",u"kind",b"kind",u"list_value",b"list_value",u"null_value",b"null_value",u"number_value",b"number_value",u"string_value",b"string_value",u"struct_value",b"struct_value"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"bool_value",b"bool_value",u"kind",b"kind",u"list_value",b"list_value",u"null_value",b"null_value",u"number_value",b"number_value",u"string_value",b"string_value",u"struct_value",b"struct_value"]) -> None: ... - def WhichOneof(self, oneof_group: typing_extensions.Literal[u"kind",b"kind"]) -> typing.Optional[typing_extensions.Literal["null_value","number_value","string_value","bool_value","struct_value","list_value"]]: ... + def HasField(self, field_name: typing_extensions.Literal["bool_value",b"bool_value","kind",b"kind","list_value",b"list_value","null_value",b"null_value","number_value",b"number_value","string_value",b"string_value","struct_value",b"struct_value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["bool_value",b"bool_value","kind",b"kind","list_value",b"list_value","null_value",b"null_value","number_value",b"number_value","string_value",b"string_value","struct_value",b"struct_value"]) -> None: ... + def WhichOneof(self, oneof_group: typing_extensions.Literal["kind",b"kind"]) -> typing.Optional[typing_extensions.Literal["null_value","number_value","string_value","bool_value","struct_value","list_value"]]: ... global___Value = Value -# `ListValue` is a wrapper around a repeated field of values. -# -# The JSON representation for `ListValue` is JSON array. class ListValue(google.protobuf.message.Message, google.protobuf.internal.well_known_types.ListValue): + """`ListValue` is a wrapper around a repeated field of values. + + The JSON representation for `ListValue` is JSON array. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... VALUES_FIELD_NUMBER: builtins.int - # Repeated field of dynamically typed values. @property - def values(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Value]: ... + def values(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Value]: + """Repeated field of dynamically typed values.""" + pass def __init__(self, *, values : typing.Optional[typing.Iterable[global___Value]] = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"values",b"values"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["values",b"values"]) -> None: ... global___ListValue = ListValue diff --git a/stubs/protobuf/google/protobuf/text_format.pyi b/stubs/protobuf/google/protobuf/text_format.pyi index 7fe57b642..eafb77a63 100644 --- a/stubs/protobuf/google/protobuf/text_format.pyi +++ b/stubs/protobuf/google/protobuf/text_format.pyi @@ -200,7 +200,7 @@ class Tokenizer: def TryConsumeIdentifierOrNumber(self) -> bool: ... def ConsumeIdentifierOrNumber(self) -> str: ... def TryConsumeInteger(self) -> bool: ... - def ConsumeInteger(self, is_long: bool = ...) -> int: ... + def ConsumeInteger(self) -> int: ... def TryConsumeFloat(self) -> bool: ... def ConsumeFloat(self) -> float: ... def ConsumeBool(self) -> bool: ... diff --git a/stubs/protobuf/google/protobuf/timestamp_pb2.pyi b/stubs/protobuf/google/protobuf/timestamp_pb2.pyi index 2eb95333f..846004d18 100644 --- a/stubs/protobuf/google/protobuf/timestamp_pb2.pyi +++ b/stubs/protobuf/google/protobuf/timestamp_pb2.pyi @@ -10,114 +10,119 @@ import typing_extensions DESCRIPTOR: google.protobuf.descriptor.FileDescriptor = ... -# A Timestamp represents a point in time independent of any time zone or local -# calendar, encoded as a count of seconds and fractions of seconds at -# nanosecond resolution. The count is relative to an epoch at UTC midnight on -# January 1, 1970, in the proleptic Gregorian calendar which extends the -# Gregorian calendar backwards to year one. -# -# All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap -# second table is needed for interpretation, using a [24-hour linear -# smear](https://developers.google.com/time/smear). -# -# The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By -# restricting to that range, we ensure that we can convert to and from [RFC -# 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. -# -# # Examples -# -# Example 1: Compute Timestamp from POSIX `time()`. -# -# Timestamp timestamp; -# timestamp.set_seconds(time(NULL)); -# timestamp.set_nanos(0); -# -# Example 2: Compute Timestamp from POSIX `gettimeofday()`. -# -# struct timeval tv; -# gettimeofday(&tv, NULL); -# -# Timestamp timestamp; -# timestamp.set_seconds(tv.tv_sec); -# timestamp.set_nanos(tv.tv_usec * 1000); -# -# Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. -# -# FILETIME ft; -# GetSystemTimeAsFileTime(&ft); -# UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; -# -# // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z -# // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. -# Timestamp timestamp; -# timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); -# timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); -# -# Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. -# -# long millis = System.currentTimeMillis(); -# -# Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) -# .setNanos((int) ((millis % 1000) * 1000000)).build(); -# -# -# Example 5: Compute Timestamp from Java `Instant.now()`. -# -# Instant now = Instant.now(); -# -# Timestamp timestamp = -# Timestamp.newBuilder().setSeconds(now.getEpochSecond()) -# .setNanos(now.getNano()).build(); -# -# -# Example 6: Compute Timestamp from current time in Python. -# -# timestamp = Timestamp() -# timestamp.GetCurrentTime() -# -# # JSON Mapping -# -# In JSON format, the Timestamp type is encoded as a string in the -# [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the -# format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" -# where {year} is always expressed using four digits while {month}, {day}, -# {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional -# seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), -# are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone -# is required. A proto3 JSON serializer should always use UTC (as indicated by -# "Z") when printing the Timestamp type and a proto3 JSON parser should be -# able to accept both UTC and other timezones (as indicated by an offset). -# -# For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past -# 01:30 UTC on January 15, 2017. -# -# In JavaScript, one can convert a Date object to this format using the -# standard -# [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) -# method. In Python, a standard `datetime.datetime` object can be converted -# to this format using -# [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with -# the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use -# the Joda Time's [`ISODateTimeFormat.dateTime()`]( -# http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D -# ) to obtain a formatter capable of generating timestamps in this format. class Timestamp(google.protobuf.message.Message, google.protobuf.internal.well_known_types.Timestamp): + """A Timestamp represents a point in time independent of any time zone or local + calendar, encoded as a count of seconds and fractions of seconds at + nanosecond resolution. The count is relative to an epoch at UTC midnight on + January 1, 1970, in the proleptic Gregorian calendar which extends the + Gregorian calendar backwards to year one. + + All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap + second table is needed for interpretation, using a [24-hour linear + smear](https://developers.google.com/time/smear). + + The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By + restricting to that range, we ensure that we can convert to and from [RFC + 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. + + # Examples + + Example 1: Compute Timestamp from POSIX `time()`. + + Timestamp timestamp; + timestamp.set_seconds(time(NULL)); + timestamp.set_nanos(0); + + Example 2: Compute Timestamp from POSIX `gettimeofday()`. + + struct timeval tv; + gettimeofday(&tv, NULL); + + Timestamp timestamp; + timestamp.set_seconds(tv.tv_sec); + timestamp.set_nanos(tv.tv_usec * 1000); + + Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. + + FILETIME ft; + GetSystemTimeAsFileTime(&ft); + UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; + + // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z + // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. + Timestamp timestamp; + timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); + timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); + + Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. + + long millis = System.currentTimeMillis(); + + Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) + .setNanos((int) ((millis % 1000) * 1000000)).build(); + + + Example 5: Compute Timestamp from Java `Instant.now()`. + + Instant now = Instant.now(); + + Timestamp timestamp = + Timestamp.newBuilder().setSeconds(now.getEpochSecond()) + .setNanos(now.getNano()).build(); + + + Example 6: Compute Timestamp from current time in Python. + + timestamp = Timestamp() + timestamp.GetCurrentTime() + + # JSON Mapping + + In JSON format, the Timestamp type is encoded as a string in the + [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the + format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" + where {year} is always expressed using four digits while {month}, {day}, + {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional + seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), + are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone + is required. A proto3 JSON serializer should always use UTC (as indicated by + "Z") when printing the Timestamp type and a proto3 JSON parser should be + able to accept both UTC and other timezones (as indicated by an offset). + + For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past + 01:30 UTC on January 15, 2017. + + In JavaScript, one can convert a Date object to this format using the + standard + [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) + method. In Python, a standard `datetime.datetime` object can be converted + to this format using + [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with + the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use + the Joda Time's [`ISODateTimeFormat.dateTime()`]( + http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D + ) to obtain a formatter capable of generating timestamps in this format. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... SECONDS_FIELD_NUMBER: builtins.int NANOS_FIELD_NUMBER: builtins.int - # Represents seconds of UTC time since Unix epoch - # 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to - # 9999-12-31T23:59:59Z inclusive. seconds: builtins.int = ... - # Non-negative fractions of a second at nanosecond resolution. Negative - # second values with fractions must still have non-negative nanos values - # that count forward in time. Must be from 0 to 999,999,999 - # inclusive. + """Represents seconds of UTC time since Unix epoch + 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to + 9999-12-31T23:59:59Z inclusive. + """ + nanos: builtins.int = ... + """Non-negative fractions of a second at nanosecond resolution. Negative + second values with fractions must still have non-negative nanos values + that count forward in time. Must be from 0 to 999,999,999 + inclusive. + """ + def __init__(self, *, seconds : builtins.int = ..., nanos : builtins.int = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"nanos",b"nanos",u"seconds",b"seconds"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["nanos",b"nanos","seconds",b"seconds"]) -> None: ... global___Timestamp = Timestamp diff --git a/stubs/protobuf/google/protobuf/type_pb2.pyi b/stubs/protobuf/google/protobuf/type_pb2.pyi index 399cb4b0a..d79a3c26a 100644 --- a/stubs/protobuf/google/protobuf/type_pb2.pyi +++ b/stubs/protobuf/google/protobuf/type_pb2.pyi @@ -14,27 +14,31 @@ import typing_extensions DESCRIPTOR: google.protobuf.descriptor.FileDescriptor = ... -# The syntax in which a protocol buffer element is defined. class Syntax(_Syntax, metaclass=_SyntaxEnumTypeWrapper): + """The syntax in which a protocol buffer element is defined.""" pass class _Syntax: V = typing.NewType('V', builtins.int) class _SyntaxEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_Syntax.V], builtins.type): DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor = ... - # Syntax `proto2`. SYNTAX_PROTO2 = Syntax.V(0) - # Syntax `proto3`. - SYNTAX_PROTO3 = Syntax.V(1) + """Syntax `proto2`.""" + + SYNTAX_PROTO3 = Syntax.V(1) + """Syntax `proto3`.""" + -# Syntax `proto2`. SYNTAX_PROTO2 = Syntax.V(0) -# Syntax `proto3`. +"""Syntax `proto2`.""" + SYNTAX_PROTO3 = Syntax.V(1) +"""Syntax `proto3`.""" + global___Syntax = Syntax -# A protocol buffer message type. class Type(google.protobuf.message.Message): + """A protocol buffer message type.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_FIELD_NUMBER: builtins.int FIELDS_FIELD_NUMBER: builtins.int @@ -42,22 +46,28 @@ class Type(google.protobuf.message.Message): OPTIONS_FIELD_NUMBER: builtins.int SOURCE_CONTEXT_FIELD_NUMBER: builtins.int SYNTAX_FIELD_NUMBER: builtins.int - # The fully qualified message name. name: typing.Text = ... - # The list of fields. + """The fully qualified message name.""" + @property - def fields(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Field]: ... - # The list of types appearing in `oneof` definitions in this type. + def fields(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Field]: + """The list of fields.""" + pass @property - def oneofs(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]: ... - # The protocol buffer options. + def oneofs(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]: + """The list of types appearing in `oneof` definitions in this type.""" + pass @property - def options(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Option]: ... - # The source context. + def options(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Option]: + """The protocol buffer options.""" + pass @property - def source_context(self) -> google.protobuf.source_context_pb2.SourceContext: ... - # The source syntax. + def source_context(self) -> google.protobuf.source_context_pb2.SourceContext: + """The source context.""" + pass syntax: global___Syntax.V = ... + """The source syntax.""" + def __init__(self, *, name : typing.Text = ..., @@ -67,122 +77,168 @@ class Type(google.protobuf.message.Message): source_context : typing.Optional[google.protobuf.source_context_pb2.SourceContext] = ..., syntax : global___Syntax.V = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"source_context",b"source_context"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"fields",b"fields",u"name",b"name",u"oneofs",b"oneofs",u"options",b"options",u"source_context",b"source_context",u"syntax",b"syntax"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["source_context",b"source_context"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["fields",b"fields","name",b"name","oneofs",b"oneofs","options",b"options","source_context",b"source_context","syntax",b"syntax"]) -> None: ... global___Type = Type -# A single field of a message type. class Field(google.protobuf.message.Message): + """A single field of a message type.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... - # Basic field types. class Kind(_Kind, metaclass=_KindEnumTypeWrapper): + """Basic field types.""" pass class _Kind: V = typing.NewType('V', builtins.int) class _KindEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_Kind.V], builtins.type): DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor = ... - # Field type unknown. TYPE_UNKNOWN = Field.Kind.V(0) - # Field type double. + """Field type unknown.""" + TYPE_DOUBLE = Field.Kind.V(1) - # Field type float. + """Field type double.""" + TYPE_FLOAT = Field.Kind.V(2) - # Field type int64. + """Field type float.""" + TYPE_INT64 = Field.Kind.V(3) - # Field type uint64. + """Field type int64.""" + TYPE_UINT64 = Field.Kind.V(4) - # Field type int32. + """Field type uint64.""" + TYPE_INT32 = Field.Kind.V(5) - # Field type fixed64. + """Field type int32.""" + TYPE_FIXED64 = Field.Kind.V(6) - # Field type fixed32. + """Field type fixed64.""" + TYPE_FIXED32 = Field.Kind.V(7) - # Field type bool. + """Field type fixed32.""" + TYPE_BOOL = Field.Kind.V(8) - # Field type string. + """Field type bool.""" + TYPE_STRING = Field.Kind.V(9) - # Field type group. Proto2 syntax only, and deprecated. + """Field type string.""" + TYPE_GROUP = Field.Kind.V(10) - # Field type message. + """Field type group. Proto2 syntax only, and deprecated.""" + TYPE_MESSAGE = Field.Kind.V(11) - # Field type bytes. + """Field type message.""" + TYPE_BYTES = Field.Kind.V(12) - # Field type uint32. + """Field type bytes.""" + TYPE_UINT32 = Field.Kind.V(13) - # Field type enum. + """Field type uint32.""" + TYPE_ENUM = Field.Kind.V(14) - # Field type sfixed32. + """Field type enum.""" + TYPE_SFIXED32 = Field.Kind.V(15) - # Field type sfixed64. + """Field type sfixed32.""" + TYPE_SFIXED64 = Field.Kind.V(16) - # Field type sint32. + """Field type sfixed64.""" + TYPE_SINT32 = Field.Kind.V(17) - # Field type sint64. + """Field type sint32.""" + TYPE_SINT64 = Field.Kind.V(18) + """Field type sint64.""" + - # Field type unknown. TYPE_UNKNOWN = Field.Kind.V(0) - # Field type double. - TYPE_DOUBLE = Field.Kind.V(1) - # Field type float. - TYPE_FLOAT = Field.Kind.V(2) - # Field type int64. - TYPE_INT64 = Field.Kind.V(3) - # Field type uint64. - TYPE_UINT64 = Field.Kind.V(4) - # Field type int32. - TYPE_INT32 = Field.Kind.V(5) - # Field type fixed64. - TYPE_FIXED64 = Field.Kind.V(6) - # Field type fixed32. - TYPE_FIXED32 = Field.Kind.V(7) - # Field type bool. - TYPE_BOOL = Field.Kind.V(8) - # Field type string. - TYPE_STRING = Field.Kind.V(9) - # Field type group. Proto2 syntax only, and deprecated. - TYPE_GROUP = Field.Kind.V(10) - # Field type message. - TYPE_MESSAGE = Field.Kind.V(11) - # Field type bytes. - TYPE_BYTES = Field.Kind.V(12) - # Field type uint32. - TYPE_UINT32 = Field.Kind.V(13) - # Field type enum. - TYPE_ENUM = Field.Kind.V(14) - # Field type sfixed32. - TYPE_SFIXED32 = Field.Kind.V(15) - # Field type sfixed64. - TYPE_SFIXED64 = Field.Kind.V(16) - # Field type sint32. - TYPE_SINT32 = Field.Kind.V(17) - # Field type sint64. - TYPE_SINT64 = Field.Kind.V(18) + """Field type unknown.""" + + TYPE_DOUBLE = Field.Kind.V(1) + """Field type double.""" + + TYPE_FLOAT = Field.Kind.V(2) + """Field type float.""" + + TYPE_INT64 = Field.Kind.V(3) + """Field type int64.""" + + TYPE_UINT64 = Field.Kind.V(4) + """Field type uint64.""" + + TYPE_INT32 = Field.Kind.V(5) + """Field type int32.""" + + TYPE_FIXED64 = Field.Kind.V(6) + """Field type fixed64.""" + + TYPE_FIXED32 = Field.Kind.V(7) + """Field type fixed32.""" + + TYPE_BOOL = Field.Kind.V(8) + """Field type bool.""" + + TYPE_STRING = Field.Kind.V(9) + """Field type string.""" + + TYPE_GROUP = Field.Kind.V(10) + """Field type group. Proto2 syntax only, and deprecated.""" + + TYPE_MESSAGE = Field.Kind.V(11) + """Field type message.""" + + TYPE_BYTES = Field.Kind.V(12) + """Field type bytes.""" + + TYPE_UINT32 = Field.Kind.V(13) + """Field type uint32.""" + + TYPE_ENUM = Field.Kind.V(14) + """Field type enum.""" + + TYPE_SFIXED32 = Field.Kind.V(15) + """Field type sfixed32.""" + + TYPE_SFIXED64 = Field.Kind.V(16) + """Field type sfixed64.""" + + TYPE_SINT32 = Field.Kind.V(17) + """Field type sint32.""" + + TYPE_SINT64 = Field.Kind.V(18) + """Field type sint64.""" + - # Whether a field is optional, required, or repeated. class Cardinality(_Cardinality, metaclass=_CardinalityEnumTypeWrapper): + """Whether a field is optional, required, or repeated.""" pass class _Cardinality: V = typing.NewType('V', builtins.int) class _CardinalityEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_Cardinality.V], builtins.type): DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor = ... - # For fields with unknown cardinality. CARDINALITY_UNKNOWN = Field.Cardinality.V(0) - # For optional fields. - CARDINALITY_OPTIONAL = Field.Cardinality.V(1) - # For required fields. Proto2 syntax only. - CARDINALITY_REQUIRED = Field.Cardinality.V(2) - # For repeated fields. - CARDINALITY_REPEATED = Field.Cardinality.V(3) + """For fields with unknown cardinality.""" + + CARDINALITY_OPTIONAL = Field.Cardinality.V(1) + """For optional fields.""" + + CARDINALITY_REQUIRED = Field.Cardinality.V(2) + """For required fields. Proto2 syntax only.""" + + CARDINALITY_REPEATED = Field.Cardinality.V(3) + """For repeated fields.""" + - # For fields with unknown cardinality. CARDINALITY_UNKNOWN = Field.Cardinality.V(0) - # For optional fields. + """For fields with unknown cardinality.""" + CARDINALITY_OPTIONAL = Field.Cardinality.V(1) - # For required fields. Proto2 syntax only. + """For optional fields.""" + CARDINALITY_REQUIRED = Field.Cardinality.V(2) - # For repeated fields. + """For required fields. Proto2 syntax only.""" + CARDINALITY_REPEATED = Field.Cardinality.V(3) + """For repeated fields.""" + KIND_FIELD_NUMBER: builtins.int CARDINALITY_FIELD_NUMBER: builtins.int @@ -194,29 +250,41 @@ class Field(google.protobuf.message.Message): OPTIONS_FIELD_NUMBER: builtins.int JSON_NAME_FIELD_NUMBER: builtins.int DEFAULT_VALUE_FIELD_NUMBER: builtins.int - # The field type. kind: global___Field.Kind.V = ... - # The field cardinality. + """The field type.""" + cardinality: global___Field.Cardinality.V = ... - # The field number. + """The field cardinality.""" + number: builtins.int = ... - # The field name. + """The field number.""" + name: typing.Text = ... - # The field type URL, without the scheme, for message or enumeration - # types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`. + """The field name.""" + type_url: typing.Text = ... - # The index of the field type in `Type.oneofs`, for message or enumeration - # types. The first type has index 1; zero means the type is not in the list. + """The field type URL, without the scheme, for message or enumeration + types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`. + """ + oneof_index: builtins.int = ... - # Whether to use alternative packed wire representation. + """The index of the field type in `Type.oneofs`, for message or enumeration + types. The first type has index 1; zero means the type is not in the list. + """ + packed: builtins.bool = ... - # The protocol buffer options. + """Whether to use alternative packed wire representation.""" + @property - def options(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Option]: ... - # The field JSON name. + def options(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Option]: + """The protocol buffer options.""" + pass json_name: typing.Text = ... - # The string value of the default value of this field. Proto2 syntax only. + """The field JSON name.""" + default_value: typing.Text = ... + """The string value of the default value of this field. Proto2 syntax only.""" + def __init__(self, *, kind : global___Field.Kind.V = ..., @@ -230,30 +298,35 @@ class Field(google.protobuf.message.Message): json_name : typing.Text = ..., default_value : typing.Text = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"cardinality",b"cardinality",u"default_value",b"default_value",u"json_name",b"json_name",u"kind",b"kind",u"name",b"name",u"number",b"number",u"oneof_index",b"oneof_index",u"options",b"options",u"packed",b"packed",u"type_url",b"type_url"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["cardinality",b"cardinality","default_value",b"default_value","json_name",b"json_name","kind",b"kind","name",b"name","number",b"number","oneof_index",b"oneof_index","options",b"options","packed",b"packed","type_url",b"type_url"]) -> None: ... global___Field = Field -# Enum type definition. class Enum(google.protobuf.message.Message): + """Enum type definition.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_FIELD_NUMBER: builtins.int ENUMVALUE_FIELD_NUMBER: builtins.int OPTIONS_FIELD_NUMBER: builtins.int SOURCE_CONTEXT_FIELD_NUMBER: builtins.int SYNTAX_FIELD_NUMBER: builtins.int - # Enum type name. name: typing.Text = ... - # Enum value definitions. + """Enum type name.""" + @property - def enumvalue(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___EnumValue]: ... - # Protocol buffer options. + def enumvalue(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___EnumValue]: + """Enum value definitions.""" + pass @property - def options(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Option]: ... - # The source context. + def options(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Option]: + """Protocol buffer options.""" + pass @property - def source_context(self) -> google.protobuf.source_context_pb2.SourceContext: ... - # The source syntax. + def source_context(self) -> google.protobuf.source_context_pb2.SourceContext: + """The source context.""" + pass syntax: global___Syntax.V = ... + """The source syntax.""" + def __init__(self, *, name : typing.Text = ..., @@ -262,54 +335,62 @@ class Enum(google.protobuf.message.Message): source_context : typing.Optional[google.protobuf.source_context_pb2.SourceContext] = ..., syntax : global___Syntax.V = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"source_context",b"source_context"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"enumvalue",b"enumvalue",u"name",b"name",u"options",b"options",u"source_context",b"source_context",u"syntax",b"syntax"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["source_context",b"source_context"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["enumvalue",b"enumvalue","name",b"name","options",b"options","source_context",b"source_context","syntax",b"syntax"]) -> None: ... global___Enum = Enum -# Enum value definition. class EnumValue(google.protobuf.message.Message): + """Enum value definition.""" DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_FIELD_NUMBER: builtins.int NUMBER_FIELD_NUMBER: builtins.int OPTIONS_FIELD_NUMBER: builtins.int - # Enum value name. name: typing.Text = ... - # Enum value number. + """Enum value name.""" + number: builtins.int = ... - # Protocol buffer options. + """Enum value number.""" + @property - def options(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Option]: ... + def options(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Option]: + """Protocol buffer options.""" + pass def __init__(self, *, name : typing.Text = ..., number : builtins.int = ..., options : typing.Optional[typing.Iterable[global___Option]] = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"name",b"name",u"number",b"number",u"options",b"options"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["name",b"name","number",b"number","options",b"options"]) -> None: ... global___EnumValue = EnumValue -# A protocol buffer option, which can be attached to a message, field, -# enumeration, etc. class Option(google.protobuf.message.Message): + """A protocol buffer option, which can be attached to a message, field, + enumeration, etc. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... NAME_FIELD_NUMBER: builtins.int VALUE_FIELD_NUMBER: builtins.int - # The option's name. For protobuf built-in options (options defined in - # descriptor.proto), this is the short name. For example, `"map_entry"`. - # For custom options, it should be the fully-qualified name. For example, - # `"google.api.http"`. name: typing.Text = ... - # The option's value packed in an Any message. If the value is a primitive, - # the corresponding wrapper type defined in google/protobuf/wrappers.proto - # should be used. If the value is an enum, it should be stored as an int32 - # value using the google.protobuf.Int32Value type. + """The option's name. For protobuf built-in options (options defined in + descriptor.proto), this is the short name. For example, `"map_entry"`. + For custom options, it should be the fully-qualified name. For example, + `"google.api.http"`. + """ + @property - def value(self) -> google.protobuf.any_pb2.Any: ... + def value(self) -> google.protobuf.any_pb2.Any: + """The option's value packed in an Any message. If the value is a primitive, + the corresponding wrapper type defined in google/protobuf/wrappers.proto + should be used. If the value is an enum, it should be stored as an int32 + value using the google.protobuf.Int32Value type. + """ + pass def __init__(self, *, name : typing.Text = ..., value : typing.Optional[google.protobuf.any_pb2.Any] = ..., ) -> None: ... - def HasField(self, field_name: typing_extensions.Literal[u"value",b"value"]) -> builtins.bool: ... - def ClearField(self, field_name: typing_extensions.Literal[u"name",b"name",u"value",b"value"]) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["value",b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["name",b"name","value",b"value"]) -> None: ... global___Option = Option diff --git a/stubs/protobuf/google/protobuf/wrappers_pb2.pyi b/stubs/protobuf/google/protobuf/wrappers_pb2.pyi index 52e4f5080..f4cdb76be 100644 --- a/stubs/protobuf/google/protobuf/wrappers_pb2.pyi +++ b/stubs/protobuf/google/protobuf/wrappers_pb2.pyi @@ -10,137 +10,155 @@ import typing_extensions DESCRIPTOR: google.protobuf.descriptor.FileDescriptor = ... -# Wrapper message for `double`. -# -# The JSON representation for `DoubleValue` is JSON number. class DoubleValue(google.protobuf.message.Message): + """Wrapper message for `double`. + + The JSON representation for `DoubleValue` is JSON number. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... VALUE_FIELD_NUMBER: builtins.int - # The double value. value: builtins.float = ... + """The double value.""" + def __init__(self, *, value : builtins.float = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"value",b"value"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["value",b"value"]) -> None: ... global___DoubleValue = DoubleValue -# Wrapper message for `float`. -# -# The JSON representation for `FloatValue` is JSON number. class FloatValue(google.protobuf.message.Message): + """Wrapper message for `float`. + + The JSON representation for `FloatValue` is JSON number. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... VALUE_FIELD_NUMBER: builtins.int - # The float value. value: builtins.float = ... + """The float value.""" + def __init__(self, *, value : builtins.float = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"value",b"value"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["value",b"value"]) -> None: ... global___FloatValue = FloatValue -# Wrapper message for `int64`. -# -# The JSON representation for `Int64Value` is JSON string. class Int64Value(google.protobuf.message.Message): + """Wrapper message for `int64`. + + The JSON representation for `Int64Value` is JSON string. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... VALUE_FIELD_NUMBER: builtins.int - # The int64 value. value: builtins.int = ... + """The int64 value.""" + def __init__(self, *, value : builtins.int = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"value",b"value"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["value",b"value"]) -> None: ... global___Int64Value = Int64Value -# Wrapper message for `uint64`. -# -# The JSON representation for `UInt64Value` is JSON string. class UInt64Value(google.protobuf.message.Message): + """Wrapper message for `uint64`. + + The JSON representation for `UInt64Value` is JSON string. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... VALUE_FIELD_NUMBER: builtins.int - # The uint64 value. value: builtins.int = ... + """The uint64 value.""" + def __init__(self, *, value : builtins.int = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"value",b"value"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["value",b"value"]) -> None: ... global___UInt64Value = UInt64Value -# Wrapper message for `int32`. -# -# The JSON representation for `Int32Value` is JSON number. class Int32Value(google.protobuf.message.Message): + """Wrapper message for `int32`. + + The JSON representation for `Int32Value` is JSON number. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... VALUE_FIELD_NUMBER: builtins.int - # The int32 value. value: builtins.int = ... + """The int32 value.""" + def __init__(self, *, value : builtins.int = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"value",b"value"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["value",b"value"]) -> None: ... global___Int32Value = Int32Value -# Wrapper message for `uint32`. -# -# The JSON representation for `UInt32Value` is JSON number. class UInt32Value(google.protobuf.message.Message): + """Wrapper message for `uint32`. + + The JSON representation for `UInt32Value` is JSON number. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... VALUE_FIELD_NUMBER: builtins.int - # The uint32 value. value: builtins.int = ... + """The uint32 value.""" + def __init__(self, *, value : builtins.int = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"value",b"value"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["value",b"value"]) -> None: ... global___UInt32Value = UInt32Value -# Wrapper message for `bool`. -# -# The JSON representation for `BoolValue` is JSON `true` and `false`. class BoolValue(google.protobuf.message.Message): + """Wrapper message for `bool`. + + The JSON representation for `BoolValue` is JSON `true` and `false`. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... VALUE_FIELD_NUMBER: builtins.int - # The bool value. value: builtins.bool = ... + """The bool value.""" + def __init__(self, *, value : builtins.bool = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"value",b"value"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["value",b"value"]) -> None: ... global___BoolValue = BoolValue -# Wrapper message for `string`. -# -# The JSON representation for `StringValue` is JSON string. class StringValue(google.protobuf.message.Message): + """Wrapper message for `string`. + + The JSON representation for `StringValue` is JSON string. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... VALUE_FIELD_NUMBER: builtins.int - # The string value. value: typing.Text = ... + """The string value.""" + def __init__(self, *, value : typing.Text = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"value",b"value"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["value",b"value"]) -> None: ... global___StringValue = StringValue -# Wrapper message for `bytes`. -# -# The JSON representation for `BytesValue` is JSON string. class BytesValue(google.protobuf.message.Message): + """Wrapper message for `bytes`. + + The JSON representation for `BytesValue` is JSON string. + """ DESCRIPTOR: google.protobuf.descriptor.Descriptor = ... VALUE_FIELD_NUMBER: builtins.int - # The bytes value. value: builtins.bytes = ... + """The bytes value.""" + def __init__(self, *, value : builtins.bytes = ..., ) -> None: ... - def ClearField(self, field_name: typing_extensions.Literal[u"value",b"value"]) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["value",b"value"]) -> None: ... global___BytesValue = BytesValue