diff --git a/betterproto/lib/__init__.py b/betterproto/lib/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/betterproto/lib/google/__init__.py b/betterproto/lib/google/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/betterproto/lib/google/protobuf.py b/betterproto/lib/google/protobuf.py new file mode 100644 index 0000000..fd379d5 --- /dev/null +++ b/betterproto/lib/google/protobuf.py @@ -0,0 +1,1312 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# sources: google/protobuf/any.proto, google/protobuf/source_context.proto, google/protobuf/type.proto, google/protobuf/api.proto, google/protobuf/descriptor.proto, google/protobuf/duration.proto, google/protobuf/empty.proto, google/protobuf/field_mask.proto, google/protobuf/struct.proto, google/protobuf/timestamp.proto, google/protobuf/wrappers.proto +# plugin: python-betterproto +from dataclasses import dataclass +from typing import Dict, List + +import betterproto + + +class Syntax(betterproto.Enum): + """The syntax in which a protocol buffer element is defined.""" + + # Syntax `proto2`. + SYNTAX_PROTO2 = 0 + # Syntax `proto3`. + SYNTAX_PROTO3 = 1 + + +class FieldKind(betterproto.Enum): + TYPE_UNKNOWN = 0 + TYPE_DOUBLE = 1 + TYPE_FLOAT = 2 + TYPE_INT64 = 3 + TYPE_UINT64 = 4 + TYPE_INT32 = 5 + TYPE_FIXED64 = 6 + TYPE_FIXED32 = 7 + TYPE_BOOL = 8 + TYPE_STRING = 9 + TYPE_GROUP = 10 + TYPE_MESSAGE = 11 + TYPE_BYTES = 12 + TYPE_UINT32 = 13 + TYPE_ENUM = 14 + TYPE_SFIXED32 = 15 + TYPE_SFIXED64 = 16 + TYPE_SINT32 = 17 + TYPE_SINT64 = 18 + + +class FieldCardinality(betterproto.Enum): + CARDINALITY_UNKNOWN = 0 + CARDINALITY_OPTIONAL = 1 + CARDINALITY_REQUIRED = 2 + CARDINALITY_REPEATED = 3 + + +class FieldDescriptorProtoType(betterproto.Enum): + TYPE_DOUBLE = 1 + TYPE_FLOAT = 2 + TYPE_INT64 = 3 + TYPE_UINT64 = 4 + TYPE_INT32 = 5 + TYPE_FIXED64 = 6 + TYPE_FIXED32 = 7 + TYPE_BOOL = 8 + TYPE_STRING = 9 + TYPE_GROUP = 10 + TYPE_MESSAGE = 11 + TYPE_BYTES = 12 + TYPE_UINT32 = 13 + TYPE_ENUM = 14 + TYPE_SFIXED32 = 15 + TYPE_SFIXED64 = 16 + TYPE_SINT32 = 17 + TYPE_SINT64 = 18 + + +class FieldDescriptorProtoLabel(betterproto.Enum): + LABEL_OPTIONAL = 1 + LABEL_REQUIRED = 2 + LABEL_REPEATED = 3 + + +class FileOptionsOptimizeMode(betterproto.Enum): + SPEED = 1 + CODE_SIZE = 2 + LITE_RUNTIME = 3 + + +class FieldOptionsCType(betterproto.Enum): + STRING = 0 + CORD = 1 + STRING_PIECE = 2 + + +class FieldOptionsJSType(betterproto.Enum): + JS_NORMAL = 0 + JS_STRING = 1 + JS_NUMBER = 2 + + +class MethodOptionsIdempotencyLevel(betterproto.Enum): + IDEMPOTENCY_UNKNOWN = 0 + NO_SIDE_EFFECTS = 1 + IDEMPOTENT = 2 + + +class NullValue(betterproto.Enum): + """ + `NullValue` is a singleton enumeration to represent the null value for the + `Value` type union. The JSON representation for `NullValue` is JSON + `null`. + """ + + # Null value. + NULL_VALUE = 0 + + +@dataclass +class Any(betterproto.Message): + """ + `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 := ptypes.MarshalAny(foo) ... + foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, 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" } + """ + + # 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: str = betterproto.string_field(1) + # Must be a valid serialized protocol buffer of the above specified type. + value: bytes = betterproto.bytes_field(2) + + +@dataclass +class SourceContext(betterproto.Message): + """ + `SourceContext` represents information about the source of a protobuf + element, like the file in which it is defined. + """ + + # The path-qualified name of the .proto file that contained the associated + # protobuf element. For example: `"google/protobuf/source_context.proto"`. + file_name: str = betterproto.string_field(1) + + +@dataclass +class Type(betterproto.Message): + """A protocol buffer message type.""" + + # The fully qualified message name. + name: str = betterproto.string_field(1) + # The list of fields. + fields: List["Field"] = betterproto.message_field(2) + # The list of types appearing in `oneof` definitions in this type. + oneofs: List[str] = betterproto.string_field(3) + # The protocol buffer options. + options: List["Option"] = betterproto.message_field(4) + # The source context. + source_context: "SourceContext" = betterproto.message_field(5) + # The source syntax. + syntax: "Syntax" = betterproto.enum_field(6) + + +@dataclass +class Field(betterproto.Message): + """A single field of a message type.""" + + # The field type. + kind: "FieldKind" = betterproto.enum_field(1) + # The field cardinality. + cardinality: "FieldCardinality" = betterproto.enum_field(2) + # The field number. + number: int = betterproto.int32_field(3) + # The field name. + name: str = betterproto.string_field(4) + # The field type URL, without the scheme, for message or enumeration types. + # Example: `"type.googleapis.com/google.protobuf.Timestamp"`. + type_url: str = betterproto.string_field(6) + # 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. + oneof_index: int = betterproto.int32_field(7) + # Whether to use alternative packed wire representation. + packed: bool = betterproto.bool_field(8) + # The protocol buffer options. + options: List["Option"] = betterproto.message_field(9) + # The field JSON name. + json_name: str = betterproto.string_field(10) + # The string value of the default value of this field. Proto2 syntax only. + default_value: str = betterproto.string_field(11) + + +@dataclass +class Enum(betterproto.Message): + """Enum type definition.""" + + # Enum type name. + name: str = betterproto.string_field(1) + # Enum value definitions. + enumvalue: List["EnumValue"] = betterproto.message_field( + 2, wraps=betterproto.TYPE_ENUM + ) + # Protocol buffer options. + options: List["Option"] = betterproto.message_field(3) + # The source context. + source_context: "SourceContext" = betterproto.message_field(4) + # The source syntax. + syntax: "Syntax" = betterproto.enum_field(5) + + +@dataclass +class EnumValue(betterproto.Message): + """Enum value definition.""" + + # Enum value name. + name: str = betterproto.string_field(1) + # Enum value number. + number: int = betterproto.int32_field(2) + # Protocol buffer options. + options: List["Option"] = betterproto.message_field(3) + + +@dataclass +class Option(betterproto.Message): + """ + A protocol buffer option, which can be attached to a message, field, + enumeration, etc. + """ + + # 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: str = betterproto.string_field(1) + # 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. + value: "Any" = betterproto.message_field(2) + + +@dataclass +class Api(betterproto.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. + """ + + # The fully qualified name of this interface, including package name followed + # by the interface's simple name. + name: str = betterproto.string_field(1) + # The methods of this interface, in unspecified order. + methods: List["Method"] = betterproto.message_field(2) + # Any metadata attached to the interface. + options: List["Option"] = betterproto.message_field(3) + # 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. + version: str = betterproto.string_field(4) + # Source context for the protocol buffer service represented by this message. + source_context: "SourceContext" = betterproto.message_field(5) + # Included interfaces. See [Mixin][]. + mixins: List["Mixin"] = betterproto.message_field(6) + # The source syntax of the service. + syntax: "Syntax" = betterproto.enum_field(7) + + +@dataclass +class Method(betterproto.Message): + """Method represents a method of an API interface.""" + + # The simple name of this method. + name: str = betterproto.string_field(1) + # A URL of the input message type. + request_type_url: str = betterproto.string_field(2) + # If true, the request is streamed. + request_streaming: bool = betterproto.bool_field(3) + # The URL of the output message type. + response_type_url: str = betterproto.string_field(4) + # If true, the response is streamed. + response_streaming: bool = betterproto.bool_field(5) + # Any metadata attached to the method. + options: List["Option"] = betterproto.message_field(6) + # The source syntax of this method. + syntax: "Syntax" = betterproto.enum_field(7) + + +@dataclass +class Mixin(betterproto.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 + inherting 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"; } + ... } + """ + + # The fully qualified name of the interface which is included. + name: str = betterproto.string_field(1) + # If non-empty specifies a path under which inherited HTTP paths are rooted. + root: str = betterproto.string_field(2) + + +@dataclass +class FileDescriptorSet(betterproto.Message): + """ + The protocol compiler can output a FileDescriptorSet containing the .proto + files it parses. + """ + + file: List["FileDescriptorProto"] = betterproto.message_field(1) + + +@dataclass +class FileDescriptorProto(betterproto.Message): + """Describes a complete .proto file.""" + + name: str = betterproto.string_field(1) + package: str = betterproto.string_field(2) + # Names of files imported by this file. + dependency: List[str] = betterproto.string_field(3) + # Indexes of the public imported files in the dependency list above. + public_dependency: List[int] = betterproto.int32_field(10) + # Indexes of the weak imported files in the dependency list. For Google- + # internal migration only. Do not use. + weak_dependency: List[int] = betterproto.int32_field(11) + # All top-level definitions in this file. + message_type: List["DescriptorProto"] = betterproto.message_field(4) + enum_type: List["EnumDescriptorProto"] = betterproto.message_field(5) + service: List["ServiceDescriptorProto"] = betterproto.message_field(6) + extension: List["FieldDescriptorProto"] = betterproto.message_field(7) + options: "FileOptions" = betterproto.message_field(8) + # 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. + source_code_info: "SourceCodeInfo" = betterproto.message_field(9) + # The syntax of the proto file. The supported values are "proto2" and + # "proto3". + syntax: str = betterproto.string_field(12) + + +@dataclass +class DescriptorProto(betterproto.Message): + """Describes a message type.""" + + name: str = betterproto.string_field(1) + field: List["FieldDescriptorProto"] = betterproto.message_field(2) + extension: List["FieldDescriptorProto"] = betterproto.message_field(6) + nested_type: List["DescriptorProto"] = betterproto.message_field(3) + enum_type: List["EnumDescriptorProto"] = betterproto.message_field(4) + extension_range: List["DescriptorProtoExtensionRange"] = betterproto.message_field( + 5 + ) + oneof_decl: List["OneofDescriptorProto"] = betterproto.message_field(8) + options: "MessageOptions" = betterproto.message_field(7) + reserved_range: List["DescriptorProtoReservedRange"] = betterproto.message_field(9) + # Reserved field names, which may not be used by fields in the same message. + # A given name may only be reserved once. + reserved_name: List[str] = betterproto.string_field(10) + + +@dataclass +class DescriptorProtoExtensionRange(betterproto.Message): + start: int = betterproto.int32_field(1) + end: int = betterproto.int32_field(2) + options: "ExtensionRangeOptions" = betterproto.message_field(3) + + +@dataclass +class DescriptorProtoReservedRange(betterproto.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. + """ + + start: int = betterproto.int32_field(1) + end: int = betterproto.int32_field(2) + + +@dataclass +class ExtensionRangeOptions(betterproto.Message): + # The parser stores options it doesn't recognize here. See above. + uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999) + + +@dataclass +class FieldDescriptorProto(betterproto.Message): + """Describes a field within a message.""" + + name: str = betterproto.string_field(1) + number: int = betterproto.int32_field(3) + label: "FieldDescriptorProtoLabel" = betterproto.enum_field(4) + # 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: "FieldDescriptorProtoType" = betterproto.enum_field(5) + # 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). + type_name: str = betterproto.string_field(6) + # For extensions, this is the name of the type being extended. It is + # resolved in the same manner as type_name. + extendee: str = betterproto.string_field(2) + # 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? + default_value: str = betterproto.string_field(7) + # If set, gives the index of a oneof in the containing type's oneof_decl + # list. This field is a member of that oneof. + oneof_index: int = betterproto.int32_field(9) + # 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. + json_name: str = betterproto.string_field(10) + options: "FieldOptions" = betterproto.message_field(8) + + +@dataclass +class OneofDescriptorProto(betterproto.Message): + """Describes a oneof.""" + + name: str = betterproto.string_field(1) + options: "OneofOptions" = betterproto.message_field(2) + + +@dataclass +class EnumDescriptorProto(betterproto.Message): + """Describes an enum type.""" + + name: str = betterproto.string_field(1) + value: List["EnumValueDescriptorProto"] = betterproto.message_field( + 2, wraps=betterproto.TYPE_ENUM + ) + options: "EnumOptions" = betterproto.message_field(3) + # 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. + reserved_range: List[ + "EnumDescriptorProtoEnumReservedRange" + ] = betterproto.message_field(4) + # Reserved enum value names, which may not be reused. A given name may only + # be reserved once. + reserved_name: List[str] = betterproto.string_field(5) + + +@dataclass +class EnumDescriptorProtoEnumReservedRange(betterproto.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. + """ + + start: int = betterproto.int32_field(1) + end: int = betterproto.int32_field(2) + + +@dataclass +class EnumValueDescriptorProto(betterproto.Message): + """Describes a value within an enum.""" + + name: str = betterproto.string_field(1) + number: int = betterproto.int32_field(2) + options: "EnumValueOptions" = betterproto.message_field( + 3, wraps=betterproto.TYPE_ENUM + ) + + +@dataclass +class ServiceDescriptorProto(betterproto.Message): + """Describes a service.""" + + name: str = betterproto.string_field(1) + method: List["MethodDescriptorProto"] = betterproto.message_field(2) + options: "ServiceOptions" = betterproto.message_field(3) + + +@dataclass +class MethodDescriptorProto(betterproto.Message): + """Describes a method of a service.""" + + name: str = betterproto.string_field(1) + # 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: str = betterproto.string_field(2) + output_type: str = betterproto.string_field(3) + options: "MethodOptions" = betterproto.message_field(4) + # Identifies if client streams multiple client messages + client_streaming: bool = betterproto.bool_field(5) + # Identifies if server streams multiple server messages + server_streaming: bool = betterproto.bool_field(6) + + +@dataclass +class FileOptions(betterproto.Message): + # 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: str = betterproto.string_field(1) + # If set, all the classes from the .proto file are wrapped in a single outer + # class with the given name. This applies to both Proto1 (equivalent to the + # old "--one_java_file" option) and Proto2 (where a .proto always translates + # to a single class, but you may want to explicitly choose the class name). + java_outer_classname: str = betterproto.string_field(8) + # If set true, 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 outer class named + # by java_outer_classname. However, the outer class will still be generated + # to contain the file's getDescriptor() method as well as any top-level + # extensions defined in the file. + java_multiple_files: bool = betterproto.bool_field(10) + # This option does nothing. + java_generate_equals_and_hash: bool = betterproto.bool_field(20) + # 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. + java_string_check_utf8: bool = betterproto.bool_field(27) + optimize_for: "FileOptionsOptimizeMode" = betterproto.enum_field(9) + # 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: str = betterproto.string_field(11) + # 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. + cc_generic_services: bool = betterproto.bool_field(16) + java_generic_services: bool = betterproto.bool_field(17) + py_generic_services: bool = betterproto.bool_field(18) + php_generic_services: bool = betterproto.bool_field(42) + # 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: bool = betterproto.bool_field(23) + # Enables the use of arenas for the proto messages in this file. This applies + # only to generated classes for C++. + cc_enable_arenas: bool = betterproto.bool_field(31) + # Sets the objective c class prefix which is prepended to all objective c + # generated classes from this .proto. There is no default. + objc_class_prefix: str = betterproto.string_field(36) + # Namespace for generated classes; defaults to the package. + csharp_namespace: str = betterproto.string_field(37) + # 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. + swift_prefix: str = betterproto.string_field(39) + # Sets the php class prefix which is prepended to all php generated classes + # from this .proto. Default is empty. + php_class_prefix: str = betterproto.string_field(40) + # 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_namespace: str = betterproto.string_field(41) + # 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. + php_metadata_namespace: str = betterproto.string_field(44) + # 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. + ruby_package: str = betterproto.string_field(45) + # The parser stores options it doesn't recognize here. See the documentation + # for the "Options" section above. + uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999) + + +@dataclass +class MessageOptions(betterproto.Message): + # 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: bool = betterproto.bool_field(1) + # 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". + no_standard_descriptor_accessor: bool = betterproto.bool_field(2) + # 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. + deprecated: bool = betterproto.bool_field(3) + # 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. + map_entry: bool = betterproto.bool_field(7) + # The parser stores options it doesn't recognize here. See above. + uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999) + + +@dataclass +class FieldOptions(betterproto.Message): + # 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: "FieldOptionsCType" = betterproto.enum_field(1) + # 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. + packed: bool = betterproto.bool_field(2) + # 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. + jstype: "FieldOptionsJSType" = betterproto.enum_field(6) + # 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. + lazy: bool = betterproto.bool_field(5) + # 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. + deprecated: bool = betterproto.bool_field(3) + # For Google-internal migration only. Do not use. + weak: bool = betterproto.bool_field(10) + # The parser stores options it doesn't recognize here. See above. + uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999) + + +@dataclass +class OneofOptions(betterproto.Message): + # The parser stores options it doesn't recognize here. See above. + uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999) + + +@dataclass +class EnumOptions(betterproto.Message): + # Set this option to true to allow mapping different tag names to the same + # value. + allow_alias: bool = betterproto.bool_field(2) + # 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. + deprecated: bool = betterproto.bool_field(3) + # The parser stores options it doesn't recognize here. See above. + uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999) + + +@dataclass +class EnumValueOptions(betterproto.Message): + # 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: bool = betterproto.bool_field(1) + # The parser stores options it doesn't recognize here. See above. + uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999) + + +@dataclass +class ServiceOptions(betterproto.Message): + # 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: bool = betterproto.bool_field(33) + # The parser stores options it doesn't recognize here. See above. + uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999) + + +@dataclass +class MethodOptions(betterproto.Message): + # 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: bool = betterproto.bool_field(33) + idempotency_level: "MethodOptionsIdempotencyLevel" = betterproto.enum_field(34) + # The parser stores options it doesn't recognize here. See above. + uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999) + + +@dataclass +class UninterpretedOption(betterproto.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. + """ + + name: List["UninterpretedOptionNamePart"] = betterproto.message_field(2) + # 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: str = betterproto.string_field(3) + positive_int_value: int = betterproto.uint64_field(4) + negative_int_value: int = betterproto.int64_field(5) + double_value: float = betterproto.double_field(6) + string_value: bytes = betterproto.bytes_field(7) + aggregate_value: str = betterproto.string_field(8) + + +@dataclass +class UninterpretedOptionNamePart(betterproto.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". + """ + + name_part: str = betterproto.string_field(1) + is_extension: bool = betterproto.bool_field(2) + + +@dataclass +class SourceCodeInfo(betterproto.Message): + """ + Encapsulates information about the original source file from which a + FileDescriptorProto was generated. + """ + + # 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. + location: List["SourceCodeInfoLocation"] = betterproto.message_field(1) + + +@dataclass +class SourceCodeInfoLocation(betterproto.Message): + # 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). + path: List[int] = betterproto.int32_field(1) + # 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. + span: List[int] = betterproto.int32_field(2) + # 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. + leading_comments: str = betterproto.string_field(3) + trailing_comments: str = betterproto.string_field(4) + leading_detached_comments: List[str] = betterproto.string_field(6) + + +@dataclass +class GeneratedCodeInfo(betterproto.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. + """ + + # An Annotation connects some span of text in generated code to an element of + # its generating .proto file. + annotation: List["GeneratedCodeInfoAnnotation"] = betterproto.message_field(1) + + +@dataclass +class GeneratedCodeInfoAnnotation(betterproto.Message): + # Identifies the element in the original source .proto file. This field is + # formatted the same as SourceCodeInfo.Location.path. + path: List[int] = betterproto.int32_field(1) + # Identifies the filesystem path to the original source .proto. + source_file: str = betterproto.string_field(2) + # Identifies the starting offset in bytes in the generated code that relates + # to the identified object. + begin: int = betterproto.int32_field(3) + # 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). + end: int = betterproto.int32_field(4) + + +@dataclass +class Duration(betterproto.Message): + """ + 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". + """ + + # 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: int = betterproto.int64_field(1) + # 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. + nanos: int = betterproto.int32_field(2) + + +@dataclass +class Empty(betterproto.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 `{}`. + """ + + pass + + +@dataclass +class FieldMask(betterproto.Message): + """ + `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. + """ + + # The set of field mask paths. + paths: List[str] = betterproto.string_field(1) + + +@dataclass +class Struct(betterproto.Message): + """ + `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. + """ + + # Unordered map of dynamically typed values. + fields: Dict[str, "Value"] = betterproto.map_field( + 1, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE + ) + + +@dataclass +class Value(betterproto.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. + """ + + # Represents a null value. + null_value: "NullValue" = betterproto.enum_field(1, group="kind") + # Represents a double value. + number_value: float = betterproto.double_field(2, group="kind") + # Represents a string value. + string_value: str = betterproto.string_field(3, group="kind") + # Represents a boolean value. + bool_value: bool = betterproto.bool_field(4, group="kind") + # Represents a structured value. + struct_value: "Struct" = betterproto.message_field(5, group="kind") + # Represents a repeated `Value`. + list_value: "ListValue" = betterproto.message_field(6, group="kind") + + +@dataclass +class ListValue(betterproto.Message): + """ + `ListValue` is a wrapper around a repeated field of values. The JSON + representation for `ListValue` is JSON array. + """ + + # Repeated field of dynamically typed values. + values: List["Value"] = betterproto.message_field(1) + + +@dataclass +class Timestamp(betterproto.Message): + """ + 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 + 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. + """ + + # 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: int = betterproto.int64_field(1) + # 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. + nanos: int = betterproto.int32_field(2) + + +@dataclass +class DoubleValue(betterproto.Message): + """ + Wrapper message for `double`. The JSON representation for `DoubleValue` is + JSON number. + """ + + # The double value. + value: float = betterproto.double_field(1) + + +@dataclass +class FloatValue(betterproto.Message): + """ + Wrapper message for `float`. The JSON representation for `FloatValue` is + JSON number. + """ + + # The float value. + value: float = betterproto.float_field(1) + + +@dataclass +class Int64Value(betterproto.Message): + """ + Wrapper message for `int64`. The JSON representation for `Int64Value` is + JSON string. + """ + + # The int64 value. + value: int = betterproto.int64_field(1) + + +@dataclass +class UInt64Value(betterproto.Message): + """ + Wrapper message for `uint64`. The JSON representation for `UInt64Value` is + JSON string. + """ + + # The uint64 value. + value: int = betterproto.uint64_field(1) + + +@dataclass +class Int32Value(betterproto.Message): + """ + Wrapper message for `int32`. The JSON representation for `Int32Value` is + JSON number. + """ + + # The int32 value. + value: int = betterproto.int32_field(1) + + +@dataclass +class UInt32Value(betterproto.Message): + """ + Wrapper message for `uint32`. The JSON representation for `UInt32Value` is + JSON number. + """ + + # The uint32 value. + value: int = betterproto.uint32_field(1) + + +@dataclass +class BoolValue(betterproto.Message): + """ + Wrapper message for `bool`. The JSON representation for `BoolValue` is JSON + `true` and `false`. + """ + + # The bool value. + value: bool = betterproto.bool_field(1) + + +@dataclass +class StringValue(betterproto.Message): + """ + Wrapper message for `string`. The JSON representation for `StringValue` is + JSON string. + """ + + # The string value. + value: str = betterproto.string_field(1) + + +@dataclass +class BytesValue(betterproto.Message): + """ + Wrapper message for `bytes`. The JSON representation for `BytesValue` is + JSON string. + """ + + # The bytes value. + value: bytes = betterproto.bytes_field(1)