diff --git a/src/betterproto2/__init__.py b/src/betterproto2/__init__.py index 5462ad37..2a0ee10b 100644 --- a/src/betterproto2/__init__.py +++ b/src/betterproto2/__init__.py @@ -1364,83 +1364,9 @@ def which_one_of(message: Message, group_name: str) -> Tuple[str, Optional[Any]] return field_name, value -# Circular import workaround: google.protobuf depends on base classes defined above. -from .lib.google.protobuf import ( # noqa - BoolValue, - BytesValue, - DoubleValue, - Duration, - EnumValue, - FloatValue, - Int32Value, - Int64Value, - StringValue, - Timestamp, - UInt32Value, - UInt64Value, -) - - -class _Duration(Duration): - @classmethod - def from_timedelta(cls, delta: timedelta, *, _1_microsecond: timedelta = timedelta(microseconds=1)) -> "_Duration": - total_ms = delta // _1_microsecond - seconds = int(total_ms / 1e6) - nanos = int((total_ms % 1e6) * 1e3) - return cls(seconds, nanos) - - def to_timedelta(self) -> timedelta: - return timedelta(seconds=self.seconds, microseconds=self.nanos / 1e3) - - @staticmethod - def delta_to_json(delta: timedelta) -> str: - parts = str(delta.total_seconds()).split(".") - if len(parts) > 1: - while len(parts[1]) not in (3, 6, 9): - parts[1] = f"{parts[1]}0" - return f"{'.'.join(parts)}s" - - -class _Timestamp(Timestamp): - @classmethod - def from_datetime(cls, dt: datetime) -> "_Timestamp": - # manual epoch offset calulation to avoid rounding errors, - # to support negative timestamps (before 1970) and skirt - # around datetime bugs (apparently 0 isn't a year in [0, 9999]??) - offset = dt - DATETIME_ZERO - # below is the same as timedelta.total_seconds() but without dividing by 1e6 - # so we end up with microseconds as integers instead of seconds as float - offset_us = (offset.days * 24 * 60 * 60 + offset.seconds) * 10**6 + offset.microseconds - seconds, us = divmod(offset_us, 10**6) - return cls(seconds, us * 1000) - - def to_datetime(self) -> datetime: - # datetime.fromtimestamp() expects a timestamp in seconds, not microseconds - # if we pass it as a floating point number, we will run into rounding errors - # see also #407 - offset = timedelta(seconds=self.seconds, microseconds=self.nanos // 1000) - return DATETIME_ZERO + offset - - @staticmethod - def timestamp_to_json(dt: datetime) -> str: - nanos = dt.microsecond * 1e3 - if dt.tzinfo is not None: - # change timezone aware datetime objects to utc - dt = dt.astimezone(timezone.utc) - copy = dt.replace(microsecond=0, tzinfo=None) - result = copy.isoformat() - if (nanos % 1e9) == 0: - # If there are 0 fractional digits, the fractional - # point '.' should be omitted when serializing. - return f"{result}Z" - if (nanos % 1e6) == 0: - # Serialize 3 fractional digits. - return f"{result}.{int(nanos // 1e6) :03d}Z" - if (nanos % 1e3) == 0: - # Serialize 6 fractional digits. - return f"{result}.{int(nanos // 1e3) :06d}Z" - # Serialize 9 fractional digits. - return f"{result}.{nanos:09d}" +# Avoid circular imports +from .internal_lib.google import protobuf as internal_lib_protobuf +from .internal_lib.google.protobuf import Duration as _Duration, Timestamp as _Timestamp def _get_wrapper(proto_type: str) -> Type: @@ -1448,14 +1374,14 @@ def _get_wrapper(proto_type: str) -> Type: # TODO: include ListValue and NullValue? return { - TYPE_BOOL: BoolValue, - TYPE_BYTES: BytesValue, - TYPE_DOUBLE: DoubleValue, - TYPE_FLOAT: FloatValue, - TYPE_ENUM: EnumValue, - TYPE_INT32: Int32Value, - TYPE_INT64: Int64Value, - TYPE_STRING: StringValue, - TYPE_UINT32: UInt32Value, - TYPE_UINT64: UInt64Value, + TYPE_BOOL: internal_lib_protobuf.BoolValue, + TYPE_BYTES: internal_lib_protobuf.BytesValue, + TYPE_DOUBLE: internal_lib_protobuf.DoubleValue, + TYPE_FLOAT: internal_lib_protobuf.FloatValue, + TYPE_ENUM: internal_lib_protobuf.EnumValue, + TYPE_INT32: internal_lib_protobuf.Int32Value, + TYPE_INT64: internal_lib_protobuf.Int64Value, + TYPE_STRING: internal_lib_protobuf.StringValue, + TYPE_UINT32: internal_lib_protobuf.UInt32Value, + TYPE_UINT64: internal_lib_protobuf.UInt64Value, }[proto_type] diff --git a/src/betterproto2/lib/__init__.py b/src/betterproto2/internal_lib/__init__.py similarity index 100% rename from src/betterproto2/lib/__init__.py rename to src/betterproto2/internal_lib/__init__.py diff --git a/src/betterproto2/lib/google/__init__.py b/src/betterproto2/internal_lib/google/__init__.py similarity index 100% rename from src/betterproto2/lib/google/__init__.py rename to src/betterproto2/internal_lib/google/__init__.py diff --git a/src/betterproto2/lib/std/google/protobuf/__init__.py b/src/betterproto2/internal_lib/google/protobuf/__init__.py similarity index 93% rename from src/betterproto2/lib/std/google/protobuf/__init__.py rename to src/betterproto2/internal_lib/google/protobuf/__init__.py index 82baff0d..3c80cb51 100644 --- a/src/betterproto2/lib/std/google/protobuf/__init__.py +++ b/src/betterproto2/internal_lib/google/protobuf/__init__.py @@ -1,5 +1,4 @@ # Generated by the protocol buffer compiler. DO NOT EDIT! -# sources: google/protobuf/any.proto, google/protobuf/api.proto, google/protobuf/duration.proto, google/protobuf/empty.proto, google/protobuf/field_mask.proto, google/protobuf/source_context.proto, google/protobuf/struct.proto, google/protobuf/timestamp.proto, google/protobuf/type.proto, google/protobuf/wrappers.proto # plugin: python-betterproto2 # This file has been @generated @@ -36,7 +35,7 @@ "Value", ) - +import datetime from dataclasses import dataclass from typing import ( Dict, @@ -577,6 +576,26 @@ class Duration(betterproto2.Message): to +999,999,999 inclusive. """ + @classmethod + def from_timedelta( + cls, delta: datetime.timedelta, *, _1_microsecond: datetime.timedelta = datetime.timedelta(microseconds=1) + ) -> "Duration": + total_ms = delta // _1_microsecond + seconds = int(total_ms / 1e6) + nanos = int((total_ms % 1e6) * 1e3) + return cls(seconds, nanos) + + def to_timedelta(self) -> datetime.timedelta: + return datetime.timedelta(seconds=self.seconds, microseconds=self.nanos / 1e3) + + @staticmethod + def delta_to_json(delta: datetime.timedelta) -> str: + parts = str(delta.total_seconds()).split(".") + if len(parts) > 1: + while len(parts[1]) not in (3, 6, 9): + parts[1] = f"{parts[1]}0" + return f"{'.'.join(parts)}s" + default_message_pool.register_message("google.protobuf", "Duration", Duration) @@ -1347,6 +1366,46 @@ class Timestamp(betterproto2.Message): inclusive. """ + @classmethod + def from_datetime(cls, dt: datetime.datetime) -> "Timestamp": + # manual epoch offset calulation to avoid rounding errors, + # to support negative timestamps (before 1970) and skirt + # around datetime bugs (apparently 0 isn't a year in [0, 9999]??) + offset = dt - datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc) + # below is the same as timedelta.total_seconds() but without dividing by 1e6 + # so we end up with microseconds as integers instead of seconds as float + offset_us = (offset.days * 24 * 60 * 60 + offset.seconds) * 10**6 + offset.microseconds + seconds, us = divmod(offset_us, 10**6) + return cls(seconds, us * 1000) + + def to_datetime(self) -> datetime.datetime: + # datetime.fromtimestamp() expects a timestamp in seconds, not microseconds + # if we pass it as a floating point number, we will run into rounding errors + # see also #407 + offset = datetime.timedelta(seconds=self.seconds, microseconds=self.nanos // 1000) + return datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc) + offset + + @staticmethod + def timestamp_to_json(dt: datetime.datetime) -> str: + nanos = dt.microsecond * 1e3 + if dt.tzinfo is not None: + # change timezone aware datetime objects to utc + dt = dt.astimezone(datetime.timezone.utc) + copy = dt.replace(microsecond=0, tzinfo=None) + result = copy.isoformat() + if (nanos % 1e9) == 0: + # If there are 0 fractional digits, the fractional + # point '.' should be omitted when serializing. + return f"{result}Z" + if (nanos % 1e6) == 0: + # Serialize 3 fractional digits. + return f"{result}.{int(nanos // 1e6) :03d}Z" + if (nanos % 1e3) == 0: + # Serialize 6 fractional digits. + return f"{result}.{int(nanos // 1e3) :06d}Z" + # Serialize 9 fractional digits. + return f"{result}.{nanos:09d}" + default_message_pool.register_message("google.protobuf", "Timestamp", Timestamp) diff --git a/src/betterproto2/lib/std/message_pool.py b/src/betterproto2/internal_lib/message_pool.py similarity index 100% rename from src/betterproto2/lib/std/message_pool.py rename to src/betterproto2/internal_lib/message_pool.py diff --git a/src/betterproto2/lib/google/protobuf/__init__.py b/src/betterproto2/lib/google/protobuf/__init__.py deleted file mode 100644 index 1bfaf68f..00000000 --- a/src/betterproto2/lib/google/protobuf/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from betterproto2.lib.std.google.protobuf import * diff --git a/src/betterproto2/lib/google/protobuf/compiler/__init__.py b/src/betterproto2/lib/google/protobuf/compiler/__init__.py deleted file mode 100644 index 08d90d8b..00000000 --- a/src/betterproto2/lib/google/protobuf/compiler/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from betterproto2.lib.std.google.protobuf.compiler import * diff --git a/src/betterproto2/lib/pydantic/__init__.py b/src/betterproto2/lib/pydantic/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/betterproto2/lib/pydantic/google/__init__.py b/src/betterproto2/lib/pydantic/google/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/betterproto2/lib/pydantic/google/protobuf/__init__.py b/src/betterproto2/lib/pydantic/google/protobuf/__init__.py deleted file mode 100644 index 57378b00..00000000 --- a/src/betterproto2/lib/pydantic/google/protobuf/__init__.py +++ /dev/null @@ -1,3084 +0,0 @@ -# Generated by the protocol buffer compiler. DO NOT EDIT! -# sources: google/protobuf/any.proto, google/protobuf/api.proto, google/protobuf/descriptor.proto, google/protobuf/duration.proto, google/protobuf/empty.proto, google/protobuf/field_mask.proto, google/protobuf/source_context.proto, google/protobuf/struct.proto, google/protobuf/timestamp.proto, google/protobuf/type.proto, google/protobuf/wrappers.proto -# plugin: python-betterproto2 -# This file has been @generated - -__all__ = ( - "Edition", - "ExtensionRangeOptionsVerificationState", - "FeatureSetEnumType", - "FeatureSetFieldPresence", - "FeatureSetJsonFormat", - "FeatureSetMessageEncoding", - "FeatureSetRepeatedFieldEncoding", - "FeatureSetUtf8Validation", - "FieldCardinality", - "FieldKind", - "FieldDescriptorProtoLabel", - "FieldDescriptorProtoType", - "FieldOptionsCType", - "FieldOptionsJsType", - "FieldOptionsOptionRetention", - "FieldOptionsOptionTargetType", - "FileOptionsOptimizeMode", - "GeneratedCodeInfoAnnotationSemantic", - "MethodOptionsIdempotencyLevel", - "NullValue", - "Syntax", - "Any", - "Api", - "BoolValue", - "BytesValue", - "DescriptorProto", - "DescriptorProtoExtensionRange", - "DescriptorProtoReservedRange", - "DoubleValue", - "Duration", - "Empty", - "Enum", - "EnumDescriptorProto", - "EnumDescriptorProtoEnumReservedRange", - "EnumOptions", - "EnumValue", - "EnumValueDescriptorProto", - "EnumValueOptions", - "ExtensionRangeOptions", - "ExtensionRangeOptionsDeclaration", - "FeatureSet", - "FeatureSetDefaults", - "FeatureSetDefaultsFeatureSetEditionDefault", - "Field", - "FieldDescriptorProto", - "FieldMask", - "FieldOptions", - "FieldOptionsEditionDefault", - "FieldOptionsFeatureSupport", - "FileDescriptorProto", - "FileDescriptorSet", - "FileOptions", - "FloatValue", - "GeneratedCodeInfo", - "GeneratedCodeInfoAnnotation", - "Int32Value", - "Int64Value", - "ListValue", - "MessageOptions", - "Method", - "MethodDescriptorProto", - "MethodOptions", - "Mixin", - "OneofDescriptorProto", - "OneofOptions", - "Option", - "ServiceDescriptorProto", - "ServiceOptions", - "SourceCodeInfo", - "SourceCodeInfoLocation", - "SourceContext", - "StringValue", - "Struct", - "Timestamp", - "Type", - "UInt32Value", - "UInt64Value", - "UninterpretedOption", - "UninterpretedOptionNamePart", - "Value", -) - -import warnings -from typing import ( - TYPE_CHECKING, - Dict, - List, - Optional, -) - -from pydantic import model_validator -from pydantic.dataclasses import dataclass - -import betterproto2 - -if TYPE_CHECKING: - pass - - -class Edition(betterproto2.Enum): - """ - The full set of known editions. - """ - - UNKNOWN = 0 - """ - A placeholder for an unknown edition value. - """ - - LEGACY = 900 - """ - A placeholder edition for specifying default behaviors *before* a feature - was first introduced. This is effectively an "infinite past". - """ - - PROTO2 = 998 - """ - Legacy syntax "editions". These pre-date editions, but behave much like - distinct editions. These can't be used to specify the edition of proto - files, but feature definitions must supply proto2/proto3 defaults for - backwards compatibility. - """ - - PROTO3 = 999 - - _2023 = 1000 - """ - Editions that have been released. The specific values are arbitrary and - should not be depended on, but they will always be time-ordered for easy - comparison. - """ - - _2024 = 1001 - - _1_TEST_ONLY = 1 - """ - Placeholder editions for testing feature resolution. These should not be - used or relied on outside of tests. - """ - - _2_TEST_ONLY = 2 - - _99997_TEST_ONLY = 99997 - - _99998_TEST_ONLY = 99998 - - _99999_TEST_ONLY = 99999 - - MAX = 2147483647 - """ - Placeholder for specifying unbounded edition support. This should only - ever be used by plugins that can expect to never require any changes to - support a new edition. - """ - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class ExtensionRangeOptionsVerificationState(betterproto2.Enum): - """ - The verification state of the extension range. - """ - - DECLARATION = 0 - """ - All the extensions of the range must be declared. - """ - - UNVERIFIED = 1 - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FeatureSetEnumType(betterproto2.Enum): - ENUM_TYPE_UNKNOWN = 0 - - OPEN = 1 - - CLOSED = 2 - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FeatureSetFieldPresence(betterproto2.Enum): - FIELD_PRESENCE_UNKNOWN = 0 - - EXPLICIT = 1 - - IMPLICIT = 2 - - LEGACY_REQUIRED = 3 - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FeatureSetJsonFormat(betterproto2.Enum): - JSON_FORMAT_UNKNOWN = 0 - - ALLOW = 1 - - LEGACY_BEST_EFFORT = 2 - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FeatureSetMessageEncoding(betterproto2.Enum): - MESSAGE_ENCODING_UNKNOWN = 0 - - LENGTH_PREFIXED = 1 - - DELIMITED = 2 - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FeatureSetRepeatedFieldEncoding(betterproto2.Enum): - REPEATED_FIELD_ENCODING_UNKNOWN = 0 - - PACKED = 1 - - EXPANDED = 2 - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FeatureSetUtf8Validation(betterproto2.Enum): - UTF8_VALIDATION_UNKNOWN = 0 - - VERIFY = 2 - - NONE = 3 - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FieldCardinality(betterproto2.Enum): - """ - Whether a field is optional, required, or repeated. - """ - - CARDINALITY_UNKNOWN = 0 - """ - For fields with unknown cardinality. - """ - - CARDINALITY_OPTIONAL = 1 - """ - For optional fields. - """ - - CARDINALITY_REQUIRED = 2 - """ - For required fields. Proto2 syntax only. - """ - - CARDINALITY_REPEATED = 3 - """ - For repeated fields. - """ - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FieldKind(betterproto2.Enum): - """ - Basic field types. - """ - - TYPE_UNKNOWN = 0 - """ - Field type unknown. - """ - - TYPE_DOUBLE = 1 - """ - Field type double. - """ - - TYPE_FLOAT = 2 - """ - Field type float. - """ - - TYPE_INT64 = 3 - """ - Field type int64. - """ - - TYPE_UINT64 = 4 - """ - Field type uint64. - """ - - TYPE_INT32 = 5 - """ - Field type int32. - """ - - TYPE_FIXED64 = 6 - """ - Field type fixed64. - """ - - TYPE_FIXED32 = 7 - """ - Field type fixed32. - """ - - TYPE_BOOL = 8 - """ - Field type bool. - """ - - TYPE_STRING = 9 - """ - Field type string. - """ - - TYPE_GROUP = 10 - """ - Field type group. Proto2 syntax only, and deprecated. - """ - - TYPE_MESSAGE = 11 - """ - Field type message. - """ - - TYPE_BYTES = 12 - """ - Field type bytes. - """ - - TYPE_UINT32 = 13 - """ - Field type uint32. - """ - - TYPE_ENUM = 14 - """ - Field type enum. - """ - - TYPE_SFIXED32 = 15 - """ - Field type sfixed32. - """ - - TYPE_SFIXED64 = 16 - """ - Field type sfixed64. - """ - - TYPE_SINT32 = 17 - """ - Field type sint32. - """ - - TYPE_SINT64 = 18 - """ - Field type sint64. - """ - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FieldDescriptorProtoLabel(betterproto2.Enum): - LABEL_OPTIONAL = 1 - """ - 0 is reserved for errors - """ - - LABEL_REPEATED = 3 - - LABEL_REQUIRED = 2 - """ - The required label is only allowed in google.protobuf. In proto3 and Editions - it's explicitly prohibited. In Editions, the `field_presence` feature - can be used to get this behavior. - """ - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FieldDescriptorProtoType(betterproto2.Enum): - TYPE_DOUBLE = 1 - """ - 0 is reserved for errors. - Order is weird for historical reasons. - """ - - TYPE_FLOAT = 2 - - TYPE_INT64 = 3 - """ - Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if - negative values are likely. - """ - - TYPE_UINT64 = 4 - - TYPE_INT32 = 5 - """ - Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if - negative values are likely. - """ - - TYPE_FIXED64 = 6 - - TYPE_FIXED32 = 7 - - TYPE_BOOL = 8 - - TYPE_STRING = 9 - - TYPE_GROUP = 10 - """ - Tag-delimited aggregate. - Group type is deprecated and not supported after google.protobuf. However, Proto3 - implementations should still be able to parse the group wire format and - treat group fields as unknown fields. In Editions, the group wire format - can be enabled via the `message_encoding` feature. - """ - - TYPE_MESSAGE = 11 - """ - Length-delimited aggregate. - """ - - TYPE_BYTES = 12 - """ - New in version 2. - """ - - TYPE_UINT32 = 13 - - TYPE_ENUM = 14 - - TYPE_SFIXED32 = 15 - - TYPE_SFIXED64 = 16 - - TYPE_SINT32 = 17 - """ - Uses ZigZag encoding. - """ - - TYPE_SINT64 = 18 - """ - Uses ZigZag encoding. - """ - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FieldOptionsCType(betterproto2.Enum): - STRING = 0 - """ - Default mode. - """ - - CORD = 1 - """ - The option [ctype=CORD] may be applied to a non-repeated field of type - "bytes". It indicates that in C++, the data should be stored in a Cord - instead of a string. For very large strings, this may reduce memory - fragmentation. It may also allow better performance when parsing from a - Cord, or when parsing with aliasing enabled, as the parsed Cord may then - alias the original buffer. - """ - - STRING_PIECE = 2 - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FieldOptionsJsType(betterproto2.Enum): - JS_NORMAL = 0 - """ - Use the default type. - """ - - JS_STRING = 1 - """ - Use JavaScript strings. - """ - - JS_NUMBER = 2 - """ - Use JavaScript numbers. - """ - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FieldOptionsOptionRetention(betterproto2.Enum): - """ - If set to RETENTION_SOURCE, the option will be omitted from the binary. - """ - - RETENTION_UNKNOWN = 0 - - RETENTION_RUNTIME = 1 - - RETENTION_SOURCE = 2 - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FieldOptionsOptionTargetType(betterproto2.Enum): - """ - This indicates the types of entities that the field may apply to when used - as an option. If it is unset, then the field may be freely used as an - option on any kind of entity. - """ - - TARGET_TYPE_UNKNOWN = 0 - - TARGET_TYPE_FILE = 1 - - TARGET_TYPE_EXTENSION_RANGE = 2 - - TARGET_TYPE_MESSAGE = 3 - - TARGET_TYPE_FIELD = 4 - - TARGET_TYPE_ONEOF = 5 - - TARGET_TYPE_ENUM = 6 - - TARGET_TYPE_ENUM_ENTRY = 7 - - TARGET_TYPE_SERVICE = 8 - - TARGET_TYPE_METHOD = 9 - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class FileOptionsOptimizeMode(betterproto2.Enum): - """ - Generated classes can be optimized for speed or code size. - """ - - SPEED = 1 - """ - Generate complete code for parsing, serialization, - """ - - CODE_SIZE = 2 - """ - etc. - - Use ReflectionOps to implement these methods. - """ - - LITE_RUNTIME = 3 - """ - Generate code using MessageLite and the lite runtime. - """ - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class GeneratedCodeInfoAnnotationSemantic(betterproto2.Enum): - """ - Represents the identified object's effect on the element in the original - .proto file. - """ - - NONE = 0 - """ - There is no effect or the effect is indescribable. - """ - - SET = 1 - """ - The element is set or otherwise mutated. - """ - - ALIAS = 2 - """ - An alias to the element is returned. - """ - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class MethodOptionsIdempotencyLevel(betterproto2.Enum): - """ - 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. - """ - - IDEMPOTENCY_UNKNOWN = 0 - - NO_SIDE_EFFECTS = 1 - """ - implies idempotent - """ - - IDEMPOTENT = 2 - """ - idempotent, but may have side effects - """ - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class NullValue(betterproto2.Enum): - """ - `NullValue` is a singleton enumeration to represent the null value for the - `Value` type union. - - The JSON representation for `NullValue` is JSON `null`. - """ - - _ = 0 - """ - Null value. - """ - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -class Syntax(betterproto2.Enum): - """ - The syntax in which a protocol buffer element is defined. - """ - - PROTO2 = 0 - """ - Syntax `proto2`. - """ - - PROTO3 = 1 - """ - Syntax `proto3`. - """ - - EDITIONS = 2 - """ - Syntax `editions`. - """ - - @classmethod - def __get_pydantic_core_schema__(cls, _source_type, _handler): - from pydantic_core import core_schema - - return core_schema.int_schema(ge=0) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Any(betterproto2.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); - } - // or ... - if (any.isSameTypeAs(Foo.getDefaultInstance())) { - foo = any.unpack(Foo.getDefaultInstance()); - } - - 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" - } - """ - - type_url: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - """ - 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. As of May 2023, there are no widely used type server - implementations and no plans to implement one. - - Schemes other than `http`, `https` (or the empty scheme) might be - used with implementation specific semantics. - """ - value: "bytes" = betterproto2.field(2, betterproto2.TYPE_BYTES) - """ - Must be a valid serialized protocol buffer of the above specified type. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Api(betterproto2.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. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - """ - The fully qualified name of this interface, including package name - followed by the interface's simple name. - """ - methods: "List[Method]" = betterproto2.field(2, betterproto2.TYPE_MESSAGE, repeated=True) - """ - The methods of this interface, in unspecified order. - """ - options: "List[Option]" = betterproto2.field(3, betterproto2.TYPE_MESSAGE, repeated=True) - """ - Any metadata attached to the interface. - """ - version: "str" = betterproto2.field(4, betterproto2.TYPE_STRING) - """ - 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. - """ - source_context: "Optional[SourceContext]" = betterproto2.field(5, betterproto2.TYPE_MESSAGE, optional=True) - """ - Source context for the protocol buffer service represented by this - message. - """ - mixins: "List[Mixin]" = betterproto2.field(6, betterproto2.TYPE_MESSAGE, repeated=True) - """ - Included interfaces. See [Mixin][]. - """ - syntax: "Syntax" = betterproto2.field(7, betterproto2.TYPE_ENUM, default_factory=lambda: Syntax.try_value(0)) - """ - The source syntax of the service. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class BoolValue(betterproto2.Message): - """ - Wrapper message for `bool`. - - The JSON representation for `BoolValue` is JSON `true` and `false`. - """ - - value: "bool" = betterproto2.field(1, betterproto2.TYPE_BOOL) - """ - The bool value. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class BytesValue(betterproto2.Message): - """ - Wrapper message for `bytes`. - - The JSON representation for `BytesValue` is JSON string. - """ - - value: "bytes" = betterproto2.field(1, betterproto2.TYPE_BYTES) - """ - The bytes value. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class DescriptorProto(betterproto2.Message): - """ - Describes a message type. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - field: "List[FieldDescriptorProto]" = betterproto2.field(2, betterproto2.TYPE_MESSAGE, repeated=True) - extension: "List[FieldDescriptorProto]" = betterproto2.field(6, betterproto2.TYPE_MESSAGE, repeated=True) - nested_type: "List[DescriptorProto]" = betterproto2.field(3, betterproto2.TYPE_MESSAGE, repeated=True) - enum_type: "List[EnumDescriptorProto]" = betterproto2.field(4, betterproto2.TYPE_MESSAGE, repeated=True) - extension_range: "List[DescriptorProtoExtensionRange]" = betterproto2.field( - 5, betterproto2.TYPE_MESSAGE, repeated=True - ) - oneof_decl: "List[OneofDescriptorProto]" = betterproto2.field(8, betterproto2.TYPE_MESSAGE, repeated=True) - options: "Optional[MessageOptions]" = betterproto2.field(7, betterproto2.TYPE_MESSAGE, optional=True) - reserved_range: "List[DescriptorProtoReservedRange]" = betterproto2.field( - 9, betterproto2.TYPE_MESSAGE, repeated=True - ) - reserved_name: "List[str]" = betterproto2.field(10, betterproto2.TYPE_STRING, repeated=True) - """ - Reserved field names, which may not be used by fields in the same message. - A given name may only be reserved once. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class DescriptorProtoExtensionRange(betterproto2.Message): - start: "int" = betterproto2.field(1, betterproto2.TYPE_INT32) - """ - Inclusive. - """ - end: "int" = betterproto2.field(2, betterproto2.TYPE_INT32) - """ - Exclusive. - """ - options: "Optional[ExtensionRangeOptions]" = betterproto2.field(3, betterproto2.TYPE_MESSAGE, optional=True) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class DescriptorProtoReservedRange(betterproto2.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" = betterproto2.field(1, betterproto2.TYPE_INT32) - """ - Inclusive. - """ - end: "int" = betterproto2.field(2, betterproto2.TYPE_INT32) - """ - Exclusive. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class DoubleValue(betterproto2.Message): - """ - Wrapper message for `double`. - - The JSON representation for `DoubleValue` is JSON number. - """ - - value: "float" = betterproto2.field(1, betterproto2.TYPE_DOUBLE) - """ - The double value. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Duration(betterproto2.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". - """ - - seconds: "int" = betterproto2.field(1, betterproto2.TYPE_INT64) - """ - 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: "int" = betterproto2.field(2, betterproto2.TYPE_INT32) - """ - 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. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Empty(betterproto2.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); - } - """ - - pass - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Enum(betterproto2.Message): - """ - Enum type definition. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - """ - Enum type name. - """ - enumvalue: "List[EnumValue]" = betterproto2.field( - 2, betterproto2.TYPE_MESSAGE, wraps=betterproto2.TYPE_ENUM, repeated=True - ) - """ - Enum value definitions. - """ - options: "List[Option]" = betterproto2.field(3, betterproto2.TYPE_MESSAGE, repeated=True) - """ - Protocol buffer options. - """ - source_context: "Optional[SourceContext]" = betterproto2.field(4, betterproto2.TYPE_MESSAGE, optional=True) - """ - The source context. - """ - syntax: "Syntax" = betterproto2.field(5, betterproto2.TYPE_ENUM, default_factory=lambda: Syntax.try_value(0)) - """ - The source syntax. - """ - edition: "str" = betterproto2.field(6, betterproto2.TYPE_STRING) - """ - The source edition string, only valid when syntax is SYNTAX_EDITIONS. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class EnumDescriptorProto(betterproto2.Message): - """ - Describes an enum type. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - value: "List[EnumValueDescriptorProto]" = betterproto2.field(2, betterproto2.TYPE_MESSAGE, repeated=True) - options: "Optional[EnumOptions]" = betterproto2.field(3, betterproto2.TYPE_MESSAGE, optional=True) - reserved_range: "List[EnumDescriptorProtoEnumReservedRange]" = betterproto2.field( - 4, betterproto2.TYPE_MESSAGE, repeated=True - ) - """ - 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_name: "List[str]" = betterproto2.field(5, betterproto2.TYPE_STRING, repeated=True) - """ - Reserved enum value names, which may not be reused. A given name may only - be reserved once. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class EnumDescriptorProtoEnumReservedRange(betterproto2.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" = betterproto2.field(1, betterproto2.TYPE_INT32) - """ - Inclusive. - """ - end: "int" = betterproto2.field(2, betterproto2.TYPE_INT32) - """ - Inclusive. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class EnumOptions(betterproto2.Message): - allow_alias: "bool" = betterproto2.field(2, betterproto2.TYPE_BOOL) - """ - Set this option to true to allow mapping different tag names to the same - value. - """ - deprecated: "bool" = betterproto2.field(3, betterproto2.TYPE_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. - """ - deprecated_legacy_json_field_conflicts: "bool" = betterproto2.field(6, betterproto2.TYPE_BOOL) - """ - Enable the legacy handling of JSON field name conflicts. This lowercases - and strips underscored from the fields before comparison in proto3 only. - The new behavior takes `json_name` into account and applies to proto2 as - well. - TODO Remove this legacy behavior once downstream teams have - had time to migrate. - """ - features: "Optional[FeatureSet]" = betterproto2.field(7, betterproto2.TYPE_MESSAGE, optional=True) - """ - Any features defined in the specific edition. - """ - uninterpreted_option: "List[UninterpretedOption]" = betterproto2.field( - 999, betterproto2.TYPE_MESSAGE, repeated=True - ) - """ - The parser stores options it doesn't recognize here. See above. - """ - - def __post_init__(self) -> None: - super().__post_init__() - if self.is_set("deprecated_legacy_json_field_conflicts"): - warnings.warn("EnumOptions.deprecated_legacy_json_field_conflicts is deprecated", DeprecationWarning) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class EnumValue(betterproto2.Message): - """ - Enum value definition. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - """ - Enum value name. - """ - number: "int" = betterproto2.field(2, betterproto2.TYPE_INT32) - """ - Enum value number. - """ - options: "List[Option]" = betterproto2.field(3, betterproto2.TYPE_MESSAGE, repeated=True) - """ - Protocol buffer options. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class EnumValueDescriptorProto(betterproto2.Message): - """ - Describes a value within an enum. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - number: "int" = betterproto2.field(2, betterproto2.TYPE_INT32) - options: "Optional[EnumValueOptions]" = betterproto2.field(3, betterproto2.TYPE_MESSAGE, optional=True) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class EnumValueOptions(betterproto2.Message): - deprecated: "bool" = betterproto2.field(1, betterproto2.TYPE_BOOL) - """ - 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. - """ - features: "Optional[FeatureSet]" = betterproto2.field(2, betterproto2.TYPE_MESSAGE, optional=True) - """ - Any features defined in the specific edition. - """ - debug_redact: "bool" = betterproto2.field(3, betterproto2.TYPE_BOOL) - """ - Indicate that fields annotated with this enum value should not be printed - out when using debug formats, e.g. when the field contains sensitive - credentials. - """ - feature_support: "Optional[FieldOptionsFeatureSupport]" = betterproto2.field( - 4, betterproto2.TYPE_MESSAGE, optional=True - ) - """ - Information about the support window of a feature value. - """ - uninterpreted_option: "List[UninterpretedOption]" = betterproto2.field( - 999, betterproto2.TYPE_MESSAGE, repeated=True - ) - """ - The parser stores options it doesn't recognize here. See above. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class ExtensionRangeOptions(betterproto2.Message): - uninterpreted_option: "List[UninterpretedOption]" = betterproto2.field( - 999, betterproto2.TYPE_MESSAGE, repeated=True - ) - """ - The parser stores options it doesn't recognize here. See above. - """ - declaration: "List[ExtensionRangeOptionsDeclaration]" = betterproto2.field( - 2, betterproto2.TYPE_MESSAGE, repeated=True - ) - """ - For external users: DO NOT USE. We are in the process of open sourcing - extension declaration and executing internal cleanups before it can be - used externally. - """ - features: "Optional[FeatureSet]" = betterproto2.field(50, betterproto2.TYPE_MESSAGE, optional=True) - """ - Any features defined in the specific edition. - """ - verification: "ExtensionRangeOptionsVerificationState" = betterproto2.field( - 3, betterproto2.TYPE_ENUM, default_factory=lambda: ExtensionRangeOptionsVerificationState.try_value(0) - ) - """ - The verification state of the range. - TODO: flip the default to DECLARATION once all empty ranges - are marked as UNVERIFIED. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class ExtensionRangeOptionsDeclaration(betterproto2.Message): - number: "int" = betterproto2.field(1, betterproto2.TYPE_INT32) - """ - The extension number declared within the extension range. - """ - full_name: "str" = betterproto2.field(2, betterproto2.TYPE_STRING) - """ - The fully-qualified name of the extension field. There must be a leading - dot in front of the full name. - """ - type: "str" = betterproto2.field(3, betterproto2.TYPE_STRING) - """ - The fully-qualified type name of the extension field. Unlike - Metadata.type, Declaration.type must have a leading dot for messages - and enums. - """ - reserved: "bool" = betterproto2.field(5, betterproto2.TYPE_BOOL) - """ - If true, indicates that the number is reserved in the extension range, - and any extension field with the number will fail to compile. Set this - when a declared extension field is deleted. - """ - repeated: "bool" = betterproto2.field(6, betterproto2.TYPE_BOOL) - """ - If true, indicates that the extension must be defined as repeated. - Otherwise the extension must be defined as optional. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class FeatureSet(betterproto2.Message): - """ - =================================================================== - Features - - TODO Enums in C++ gencode (and potentially other languages) are - not well scoped. This means that each of the feature enums below can clash - with each other. The short names we've chosen maximize call-site - readability, but leave us very open to this scenario. A future feature will - be designed and implemented to handle this, hopefully before we ever hit a - conflict here. - """ - - field_presence: "FeatureSetFieldPresence" = betterproto2.field( - 1, betterproto2.TYPE_ENUM, default_factory=lambda: FeatureSetFieldPresence.try_value(0) - ) - enum_type: "FeatureSetEnumType" = betterproto2.field( - 2, betterproto2.TYPE_ENUM, default_factory=lambda: FeatureSetEnumType.try_value(0) - ) - repeated_field_encoding: "FeatureSetRepeatedFieldEncoding" = betterproto2.field( - 3, betterproto2.TYPE_ENUM, default_factory=lambda: FeatureSetRepeatedFieldEncoding.try_value(0) - ) - utf8_validation: "FeatureSetUtf8Validation" = betterproto2.field( - 4, betterproto2.TYPE_ENUM, default_factory=lambda: FeatureSetUtf8Validation.try_value(0) - ) - message_encoding: "FeatureSetMessageEncoding" = betterproto2.field( - 5, betterproto2.TYPE_ENUM, default_factory=lambda: FeatureSetMessageEncoding.try_value(0) - ) - json_format: "FeatureSetJsonFormat" = betterproto2.field( - 6, betterproto2.TYPE_ENUM, default_factory=lambda: FeatureSetJsonFormat.try_value(0) - ) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class FeatureSetDefaults(betterproto2.Message): - """ - A compiled specification for the defaults of a set of features. These - messages are generated from FeatureSet extensions and can be used to seed - feature resolution. The resolution with this object becomes a simple search - for the closest matching edition, followed by proto merges. - """ - - defaults: "List[FeatureSetDefaultsFeatureSetEditionDefault]" = betterproto2.field( - 1, betterproto2.TYPE_MESSAGE, repeated=True - ) - minimum_edition: "Edition" = betterproto2.field( - 4, betterproto2.TYPE_ENUM, default_factory=lambda: Edition.try_value(0) - ) - """ - The minimum supported edition (inclusive) when this was constructed. - Editions before this will not have defaults. - """ - maximum_edition: "Edition" = betterproto2.field( - 5, betterproto2.TYPE_ENUM, default_factory=lambda: Edition.try_value(0) - ) - """ - The maximum known edition (inclusive) when this was constructed. Editions - after this will not have reliable defaults. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class FeatureSetDefaultsFeatureSetEditionDefault(betterproto2.Message): - """ - A map from every known edition with a unique set of defaults to its - defaults. Not all editions may be contained here. For a given edition, - the defaults at the closest matching edition ordered at or before it should - be used. This field must be in strict ascending order by edition. - """ - - edition: "Edition" = betterproto2.field(3, betterproto2.TYPE_ENUM, default_factory=lambda: Edition.try_value(0)) - overridable_features: "Optional[FeatureSet]" = betterproto2.field(4, betterproto2.TYPE_MESSAGE, optional=True) - """ - Defaults of features that can be overridden in this edition. - """ - fixed_features: "Optional[FeatureSet]" = betterproto2.field(5, betterproto2.TYPE_MESSAGE, optional=True) - """ - Defaults of features that can't be overridden in this edition. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Field(betterproto2.Message): - """ - A single field of a message type. - """ - - kind: "FieldKind" = betterproto2.field(1, betterproto2.TYPE_ENUM, default_factory=lambda: FieldKind.try_value(0)) - """ - The field type. - """ - cardinality: "FieldCardinality" = betterproto2.field( - 2, betterproto2.TYPE_ENUM, default_factory=lambda: FieldCardinality.try_value(0) - ) - """ - The field cardinality. - """ - number: "int" = betterproto2.field(3, betterproto2.TYPE_INT32) - """ - The field number. - """ - name: "str" = betterproto2.field(4, betterproto2.TYPE_STRING) - """ - The field name. - """ - type_url: "str" = betterproto2.field(6, betterproto2.TYPE_STRING) - """ - The field type URL, without the scheme, for message or enumeration - types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`. - """ - oneof_index: "int" = betterproto2.field(7, betterproto2.TYPE_INT32) - """ - 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: "bool" = betterproto2.field(8, betterproto2.TYPE_BOOL) - """ - Whether to use alternative packed wire representation. - """ - options: "List[Option]" = betterproto2.field(9, betterproto2.TYPE_MESSAGE, repeated=True) - """ - The protocol buffer options. - """ - json_name: "str" = betterproto2.field(10, betterproto2.TYPE_STRING) - """ - The field JSON name. - """ - default_value: "str" = betterproto2.field(11, betterproto2.TYPE_STRING) - """ - The string value of the default value of this field. Proto2 syntax only. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class FieldDescriptorProto(betterproto2.Message): - """ - Describes a field within a message. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - number: "int" = betterproto2.field(3, betterproto2.TYPE_INT32) - label: "FieldDescriptorProtoLabel" = betterproto2.field( - 4, betterproto2.TYPE_ENUM, default_factory=lambda: FieldDescriptorProtoLabel.try_value(0) - ) - type: "FieldDescriptorProtoType" = betterproto2.field( - 5, betterproto2.TYPE_ENUM, default_factory=lambda: FieldDescriptorProtoType.try_value(0) - ) - """ - 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: "str" = betterproto2.field(6, betterproto2.TYPE_STRING) - """ - 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: "str" = betterproto2.field(2, betterproto2.TYPE_STRING) - """ - For extensions, this is the name of the type being extended. It is - resolved in the same manner as type_name. - """ - default_value: "str" = betterproto2.field(7, betterproto2.TYPE_STRING) - """ - 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. - """ - oneof_index: "int" = betterproto2.field(9, betterproto2.TYPE_INT32) - """ - 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: "str" = betterproto2.field(10, betterproto2.TYPE_STRING) - """ - 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. - """ - options: "Optional[FieldOptions]" = betterproto2.field(8, betterproto2.TYPE_MESSAGE, optional=True) - proto3_optional: "bool" = betterproto2.field(17, betterproto2.TYPE_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 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`. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class FieldMask(betterproto2.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. - """ - - paths: "List[str]" = betterproto2.field(1, betterproto2.TYPE_STRING, repeated=True) - """ - The set of field mask paths. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class FieldOptions(betterproto2.Message): - ctype: "FieldOptionsCType" = betterproto2.field( - 1, betterproto2.TYPE_ENUM, default_factory=lambda: FieldOptionsCType.try_value(0) - ) - """ - NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead. - 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 only implemented to support use of - [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of - type "bytes" in the open source release. - TODO: make ctype actually deprecated. - """ - packed: "bool" = betterproto2.field(2, betterproto2.TYPE_BOOL) - """ - 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. This option is prohibited in - Editions, but the `repeated_field_encoding` feature can be used to control - the behavior. - """ - jstype: "FieldOptionsJsType" = betterproto2.field( - 6, betterproto2.TYPE_ENUM, default_factory=lambda: FieldOptionsJsType.try_value(0) - ) - """ - 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: "bool" = betterproto2.field(5, betterproto2.TYPE_BOOL) - """ - 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 lazy message fields are still eagerly verified to check - ill-formed wireformat or missing required fields. Calling IsInitialized() - on the outer message would fail if the inner message has missing required - fields. Failed verification would result in parsing failure (except when - uninitialized messages are acceptable). - """ - unverified_lazy: "bool" = betterproto2.field(15, betterproto2.TYPE_BOOL) - """ - unverified_lazy does no correctness checks on the byte stream. This should - only be used where lazy with verification is prohibitive for performance - reasons. - """ - deprecated: "bool" = betterproto2.field(3, betterproto2.TYPE_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. - """ - weak: "bool" = betterproto2.field(10, betterproto2.TYPE_BOOL) - """ - For Google-internal migration only. Do not use. - """ - debug_redact: "bool" = betterproto2.field(16, betterproto2.TYPE_BOOL) - """ - Indicate that the field value should not be printed out when using debug - formats, e.g. when the field contains sensitive credentials. - """ - retention: "FieldOptionsOptionRetention" = betterproto2.field( - 17, betterproto2.TYPE_ENUM, default_factory=lambda: FieldOptionsOptionRetention.try_value(0) - ) - targets: "List[FieldOptionsOptionTargetType]" = betterproto2.field( - 19, betterproto2.TYPE_ENUM, repeated=True, default_factory=lambda: FieldOptionsOptionTargetType.try_value(0) - ) - edition_defaults: "List[FieldOptionsEditionDefault]" = betterproto2.field( - 20, betterproto2.TYPE_MESSAGE, repeated=True - ) - features: "Optional[FeatureSet]" = betterproto2.field(21, betterproto2.TYPE_MESSAGE, optional=True) - """ - Any features defined in the specific edition. - """ - feature_support: "Optional[FieldOptionsFeatureSupport]" = betterproto2.field( - 22, betterproto2.TYPE_MESSAGE, optional=True - ) - uninterpreted_option: "List[UninterpretedOption]" = betterproto2.field( - 999, betterproto2.TYPE_MESSAGE, repeated=True - ) - """ - The parser stores options it doesn't recognize here. See above. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class FieldOptionsEditionDefault(betterproto2.Message): - edition: "Edition" = betterproto2.field(3, betterproto2.TYPE_ENUM, default_factory=lambda: Edition.try_value(0)) - value: "str" = betterproto2.field(2, betterproto2.TYPE_STRING) - """ - Textproto value. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class FieldOptionsFeatureSupport(betterproto2.Message): - """ - Information about the support window of a feature. - """ - - edition_introduced: "Edition" = betterproto2.field( - 1, betterproto2.TYPE_ENUM, default_factory=lambda: Edition.try_value(0) - ) - """ - The edition that this feature was first available in. In editions - earlier than this one, the default assigned to EDITION_LEGACY will be - used, and proto files will not be able to override it. - """ - edition_deprecated: "Edition" = betterproto2.field( - 2, betterproto2.TYPE_ENUM, default_factory=lambda: Edition.try_value(0) - ) - """ - The edition this feature becomes deprecated in. Using this after this - edition may trigger warnings. - """ - deprecation_warning: "str" = betterproto2.field(3, betterproto2.TYPE_STRING) - """ - The deprecation warning text if this feature is used after the edition it - was marked deprecated in. - """ - edition_removed: "Edition" = betterproto2.field( - 4, betterproto2.TYPE_ENUM, default_factory=lambda: Edition.try_value(0) - ) - """ - The edition this feature is no longer available in. In editions after - this one, the last default assigned will be used, and proto files will - not be able to override it. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class FileDescriptorProto(betterproto2.Message): - """ - Describes a complete .proto file. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - """ - file name, relative to root of source tree - """ - package: "str" = betterproto2.field(2, betterproto2.TYPE_STRING) - """ - e.g. "foo", "foo.bar", etc. - """ - dependency: "List[str]" = betterproto2.field(3, betterproto2.TYPE_STRING, repeated=True) - """ - Names of files imported by this file. - """ - public_dependency: "List[int]" = betterproto2.field(10, betterproto2.TYPE_INT32, repeated=True) - """ - Indexes of the public imported files in the dependency list above. - """ - weak_dependency: "List[int]" = betterproto2.field(11, betterproto2.TYPE_INT32, repeated=True) - """ - Indexes of the weak imported files in the dependency list. - For Google-internal migration only. Do not use. - """ - message_type: "List[DescriptorProto]" = betterproto2.field(4, betterproto2.TYPE_MESSAGE, repeated=True) - """ - All top-level definitions in this file. - """ - enum_type: "List[EnumDescriptorProto]" = betterproto2.field(5, betterproto2.TYPE_MESSAGE, repeated=True) - service: "List[ServiceDescriptorProto]" = betterproto2.field(6, betterproto2.TYPE_MESSAGE, repeated=True) - extension: "List[FieldDescriptorProto]" = betterproto2.field(7, betterproto2.TYPE_MESSAGE, repeated=True) - options: "Optional[FileOptions]" = betterproto2.field(8, betterproto2.TYPE_MESSAGE, optional=True) - source_code_info: "Optional[SourceCodeInfo]" = betterproto2.field(9, betterproto2.TYPE_MESSAGE, optional=True) - """ - 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. - """ - syntax: "str" = betterproto2.field(12, betterproto2.TYPE_STRING) - """ - The syntax of the proto file. - The supported values are "proto2", "proto3", and "editions". - - If `edition` is present, this value must be "editions". - """ - edition: "Edition" = betterproto2.field(14, betterproto2.TYPE_ENUM, default_factory=lambda: Edition.try_value(0)) - """ - The edition of the proto file. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class FileDescriptorSet(betterproto2.Message): - """ - The protocol compiler can output a FileDescriptorSet containing the .proto - files it parses. - """ - - file: "List[FileDescriptorProto]" = betterproto2.field(1, betterproto2.TYPE_MESSAGE, repeated=True) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class FileOptions(betterproto2.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. - """ - - java_package: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - """ - 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: "str" = betterproto2.field(8, betterproto2.TYPE_STRING) - """ - 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: "bool" = betterproto2.field(10, betterproto2.TYPE_BOOL) - """ - 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: "bool" = betterproto2.field(20, betterproto2.TYPE_BOOL) - """ - This option does nothing. - """ - java_string_check_utf8: "bool" = betterproto2.field(27, betterproto2.TYPE_BOOL) - """ - A proto2 file can set this to true to opt in to UTF-8 checking for Java, - which will throw an exception if invalid UTF-8 is parsed from the wire or - assigned to a string field. - - TODO: clarify exactly what kinds of field types this option - applies to, and update these docs accordingly. - - Proto3 files already perform these checks. Setting the option explicitly to - false has no effect: it cannot be used to opt proto3 files out of UTF-8 - checks. - """ - optimize_for: "FileOptionsOptimizeMode" = betterproto2.field( - 9, betterproto2.TYPE_ENUM, default_factory=lambda: FileOptionsOptimizeMode.try_value(0) - ) - go_package: "str" = betterproto2.field(11, betterproto2.TYPE_STRING) - """ - 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: "bool" = betterproto2.field(16, betterproto2.TYPE_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: "bool" = betterproto2.field(17, betterproto2.TYPE_BOOL) - py_generic_services: "bool" = betterproto2.field(18, betterproto2.TYPE_BOOL) - deprecated: "bool" = betterproto2.field(23, betterproto2.TYPE_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. - """ - cc_enable_arenas: "bool" = betterproto2.field(31, betterproto2.TYPE_BOOL) - """ - Enables the use of arenas for the proto messages in this file. This applies - only to generated classes for C++. - """ - objc_class_prefix: "str" = betterproto2.field(36, betterproto2.TYPE_STRING) - """ - Sets the objective c class prefix which is prepended to all objective c - generated classes from this .proto. There is no default. - """ - csharp_namespace: "str" = betterproto2.field(37, betterproto2.TYPE_STRING) - """ - Namespace for generated classes; defaults to the package. - """ - swift_prefix: "str" = betterproto2.field(39, betterproto2.TYPE_STRING) - """ - 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: "str" = betterproto2.field(40, betterproto2.TYPE_STRING) - """ - Sets the php class prefix which is prepended to all php generated classes - from this .proto. Default is empty. - """ - php_namespace: "str" = betterproto2.field(41, betterproto2.TYPE_STRING) - """ - 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: "str" = betterproto2.field(44, betterproto2.TYPE_STRING) - """ - 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: "str" = betterproto2.field(45, betterproto2.TYPE_STRING) - """ - 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. - """ - features: "Optional[FeatureSet]" = betterproto2.field(50, betterproto2.TYPE_MESSAGE, optional=True) - """ - Any features defined in the specific edition. - """ - uninterpreted_option: "List[UninterpretedOption]" = betterproto2.field( - 999, betterproto2.TYPE_MESSAGE, repeated=True - ) - """ - The parser stores options it doesn't recognize here. - See the documentation for the "Options" section above. - """ - - def __post_init__(self) -> None: - super().__post_init__() - if self.is_set("java_generate_equals_and_hash"): - warnings.warn("FileOptions.java_generate_equals_and_hash is deprecated", DeprecationWarning) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class FloatValue(betterproto2.Message): - """ - Wrapper message for `float`. - - The JSON representation for `FloatValue` is JSON number. - """ - - value: "float" = betterproto2.field(1, betterproto2.TYPE_FLOAT) - """ - The float value. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class GeneratedCodeInfo(betterproto2.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. - """ - - annotation: "List[GeneratedCodeInfoAnnotation]" = betterproto2.field(1, betterproto2.TYPE_MESSAGE, repeated=True) - """ - An Annotation connects some span of text in generated code to an element - of its generating .proto file. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class GeneratedCodeInfoAnnotation(betterproto2.Message): - path: "List[int]" = betterproto2.field(1, betterproto2.TYPE_INT32, repeated=True) - """ - Identifies the element in the original source .proto file. This field - is formatted the same as SourceCodeInfo.Location.path. - """ - source_file: "str" = betterproto2.field(2, betterproto2.TYPE_STRING) - """ - Identifies the filesystem path to the original source .proto. - """ - begin: "int" = betterproto2.field(3, betterproto2.TYPE_INT32) - """ - Identifies the starting offset in bytes in the generated code - that relates to the identified object. - """ - end: "int" = betterproto2.field(4, betterproto2.TYPE_INT32) - """ - Identifies the ending offset in bytes in the generated code that - relates to the identified object. The end offset should be one past - the last relevant byte (so the length of the text = end - begin). - """ - semantic: "GeneratedCodeInfoAnnotationSemantic" = betterproto2.field( - 5, betterproto2.TYPE_ENUM, default_factory=lambda: GeneratedCodeInfoAnnotationSemantic.try_value(0) - ) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Int32Value(betterproto2.Message): - """ - Wrapper message for `int32`. - - The JSON representation for `Int32Value` is JSON number. - """ - - value: "int" = betterproto2.field(1, betterproto2.TYPE_INT32) - """ - The int32 value. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Int64Value(betterproto2.Message): - """ - Wrapper message for `int64`. - - The JSON representation for `Int64Value` is JSON string. - """ - - value: "int" = betterproto2.field(1, betterproto2.TYPE_INT64) - """ - The int64 value. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class ListValue(betterproto2.Message): - """ - `ListValue` is a wrapper around a repeated field of values. - - The JSON representation for `ListValue` is JSON array. - """ - - values: "List[Value]" = betterproto2.field(1, betterproto2.TYPE_MESSAGE, repeated=True) - """ - Repeated field of dynamically typed values. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class MessageOptions(betterproto2.Message): - message_set_wire_format: "bool" = betterproto2.field(1, betterproto2.TYPE_BOOL) - """ - 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: "bool" = betterproto2.field(2, betterproto2.TYPE_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". - """ - deprecated: "bool" = betterproto2.field(3, betterproto2.TYPE_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. - """ - map_entry: "bool" = betterproto2.field(7, betterproto2.TYPE_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. - """ - deprecated_legacy_json_field_conflicts: "bool" = betterproto2.field(11, betterproto2.TYPE_BOOL) - """ - Enable the legacy handling of JSON field name conflicts. This lowercases - and strips underscored from the fields before comparison in proto3 only. - The new behavior takes `json_name` into account and applies to proto2 as - well. - - This should only be used as a temporary measure against broken builds due - to the change in behavior for JSON field name conflicts. - - TODO This is legacy behavior we plan to remove once downstream - teams have had time to migrate. - """ - features: "Optional[FeatureSet]" = betterproto2.field(12, betterproto2.TYPE_MESSAGE, optional=True) - """ - Any features defined in the specific edition. - """ - uninterpreted_option: "List[UninterpretedOption]" = betterproto2.field( - 999, betterproto2.TYPE_MESSAGE, repeated=True - ) - """ - The parser stores options it doesn't recognize here. See above. - """ - - def __post_init__(self) -> None: - super().__post_init__() - if self.is_set("deprecated_legacy_json_field_conflicts"): - warnings.warn("MessageOptions.deprecated_legacy_json_field_conflicts is deprecated", DeprecationWarning) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Method(betterproto2.Message): - """ - Method represents a method of an API interface. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - """ - The simple name of this method. - """ - request_type_url: "str" = betterproto2.field(2, betterproto2.TYPE_STRING) - """ - A URL of the input message type. - """ - request_streaming: "bool" = betterproto2.field(3, betterproto2.TYPE_BOOL) - """ - If true, the request is streamed. - """ - response_type_url: "str" = betterproto2.field(4, betterproto2.TYPE_STRING) - """ - The URL of the output message type. - """ - response_streaming: "bool" = betterproto2.field(5, betterproto2.TYPE_BOOL) - """ - If true, the response is streamed. - """ - options: "List[Option]" = betterproto2.field(6, betterproto2.TYPE_MESSAGE, repeated=True) - """ - Any metadata attached to the method. - """ - syntax: "Syntax" = betterproto2.field(7, betterproto2.TYPE_ENUM, default_factory=lambda: Syntax.try_value(0)) - """ - The source syntax of this method. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class MethodDescriptorProto(betterproto2.Message): - """ - Describes a method of a service. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - input_type: "str" = betterproto2.field(2, betterproto2.TYPE_STRING) - """ - 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: "str" = betterproto2.field(3, betterproto2.TYPE_STRING) - options: "Optional[MethodOptions]" = betterproto2.field(4, betterproto2.TYPE_MESSAGE, optional=True) - client_streaming: "bool" = betterproto2.field(5, betterproto2.TYPE_BOOL) - """ - Identifies if client streams multiple client messages - """ - server_streaming: "bool" = betterproto2.field(6, betterproto2.TYPE_BOOL) - """ - Identifies if server streams multiple server messages - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class MethodOptions(betterproto2.Message): - deprecated: "bool" = betterproto2.field(33, betterproto2.TYPE_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: "MethodOptionsIdempotencyLevel" = betterproto2.field( - 34, betterproto2.TYPE_ENUM, default_factory=lambda: MethodOptionsIdempotencyLevel.try_value(0) - ) - features: "Optional[FeatureSet]" = betterproto2.field(35, betterproto2.TYPE_MESSAGE, optional=True) - """ - Any features defined in the specific edition. - """ - uninterpreted_option: "List[UninterpretedOption]" = betterproto2.field( - 999, betterproto2.TYPE_MESSAGE, repeated=True - ) - """ - The parser stores options it doesn't recognize here. See above. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Mixin(betterproto2.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"; - } - ... - } - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - """ - The fully qualified name of the interface which is included. - """ - root: "str" = betterproto2.field(2, betterproto2.TYPE_STRING) - """ - If non-empty specifies a path under which inherited HTTP paths - are rooted. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class OneofDescriptorProto(betterproto2.Message): - """ - Describes a oneof. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - options: "Optional[OneofOptions]" = betterproto2.field(2, betterproto2.TYPE_MESSAGE, optional=True) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class OneofOptions(betterproto2.Message): - features: "Optional[FeatureSet]" = betterproto2.field(1, betterproto2.TYPE_MESSAGE, optional=True) - """ - Any features defined in the specific edition. - """ - uninterpreted_option: "List[UninterpretedOption]" = betterproto2.field( - 999, betterproto2.TYPE_MESSAGE, repeated=True - ) - """ - The parser stores options it doesn't recognize here. See above. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Option(betterproto2.Message): - """ - A protocol buffer option, which can be attached to a message, field, - enumeration, etc. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - """ - 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"`. - """ - value: "Optional[Any]" = betterproto2.field(2, betterproto2.TYPE_MESSAGE, optional=True) - """ - 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. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class ServiceDescriptorProto(betterproto2.Message): - """ - Describes a service. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - method: "List[MethodDescriptorProto]" = betterproto2.field(2, betterproto2.TYPE_MESSAGE, repeated=True) - options: "Optional[ServiceOptions]" = betterproto2.field(3, betterproto2.TYPE_MESSAGE, optional=True) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class ServiceOptions(betterproto2.Message): - features: "Optional[FeatureSet]" = betterproto2.field(34, betterproto2.TYPE_MESSAGE, optional=True) - """ - Any features defined in the specific edition. - """ - deprecated: "bool" = betterproto2.field(33, betterproto2.TYPE_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 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. - """ - uninterpreted_option: "List[UninterpretedOption]" = betterproto2.field( - 999, betterproto2.TYPE_MESSAGE, repeated=True - ) - """ - The parser stores options it doesn't recognize here. See above. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class SourceCodeInfo(betterproto2.Message): - """ - =================================================================== - Optional source code info - - Encapsulates information about the original source file from which a - FileDescriptorProto was generated. - """ - - location: "List[SourceCodeInfoLocation]" = betterproto2.field(1, betterproto2.TYPE_MESSAGE, repeated=True) - """ - 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. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class SourceCodeInfoLocation(betterproto2.Message): - path: "List[int]" = betterproto2.field(1, betterproto2.TYPE_INT32, repeated=True) - """ - 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 appears. - 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). - """ - span: "List[int]" = betterproto2.field(2, betterproto2.TYPE_INT32, repeated=True) - """ - 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. - """ - leading_comments: "str" = betterproto2.field(3, betterproto2.TYPE_STRING) - """ - 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 moo. - // - // Another line attached to moo. - optional double moo = 4; - - // Detached comment for corge. This is not leading or trailing comments - // to moo 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: "str" = betterproto2.field(4, betterproto2.TYPE_STRING) - leading_detached_comments: "List[str]" = betterproto2.field(6, betterproto2.TYPE_STRING, repeated=True) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class SourceContext(betterproto2.Message): - """ - `SourceContext` represents information about the source of a - protobuf element, like the file in which it is defined. - """ - - file_name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - """ - The path-qualified name of the .proto file that contained the associated - protobuf element. For example: `"google/protobuf/source_context.proto"`. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class StringValue(betterproto2.Message): - """ - Wrapper message for `string`. - - The JSON representation for `StringValue` is JSON string. - """ - - value: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - """ - The string value. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Struct(betterproto2.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. - """ - - fields: "Dict[str, Value]" = betterproto2.field( - 1, betterproto2.TYPE_MAP, map_types=(betterproto2.TYPE_STRING, betterproto2.TYPE_MESSAGE) - ) - """ - Unordered map of dynamically typed values. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Timestamp(betterproto2.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 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime() - ) to obtain a formatter capable of generating timestamps in this format. - """ - - seconds: "int" = betterproto2.field(1, betterproto2.TYPE_INT64) - """ - 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: "int" = betterproto2.field(2, betterproto2.TYPE_INT32) - """ - 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. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Type(betterproto2.Message): - """ - A protocol buffer message type. - """ - - name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - """ - The fully qualified message name. - """ - fields: "List[Field]" = betterproto2.field(2, betterproto2.TYPE_MESSAGE, repeated=True) - """ - The list of fields. - """ - oneofs: "List[str]" = betterproto2.field(3, betterproto2.TYPE_STRING, repeated=True) - """ - The list of types appearing in `oneof` definitions in this type. - """ - options: "List[Option]" = betterproto2.field(4, betterproto2.TYPE_MESSAGE, repeated=True) - """ - The protocol buffer options. - """ - source_context: "Optional[SourceContext]" = betterproto2.field(5, betterproto2.TYPE_MESSAGE, optional=True) - """ - The source context. - """ - syntax: "Syntax" = betterproto2.field(6, betterproto2.TYPE_ENUM, default_factory=lambda: Syntax.try_value(0)) - """ - The source syntax. - """ - edition: "str" = betterproto2.field(7, betterproto2.TYPE_STRING) - """ - The source edition string, only valid when syntax is SYNTAX_EDITIONS. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class UInt32Value(betterproto2.Message): - """ - Wrapper message for `uint32`. - - The JSON representation for `UInt32Value` is JSON number. - """ - - value: "int" = betterproto2.field(1, betterproto2.TYPE_UINT32) - """ - The uint32 value. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class UInt64Value(betterproto2.Message): - """ - Wrapper message for `uint64`. - - The JSON representation for `UInt64Value` is JSON string. - """ - - value: "int" = betterproto2.field(1, betterproto2.TYPE_UINT64) - """ - The uint64 value. - """ - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class UninterpretedOption(betterproto2.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]" = betterproto2.field(2, betterproto2.TYPE_MESSAGE, repeated=True) - identifier_value: "str" = betterproto2.field(3, betterproto2.TYPE_STRING) - """ - 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: "int" = betterproto2.field(4, betterproto2.TYPE_UINT64) - negative_int_value: "int" = betterproto2.field(5, betterproto2.TYPE_INT64) - double_value: "float" = betterproto2.field(6, betterproto2.TYPE_DOUBLE) - string_value: "bytes" = betterproto2.field(7, betterproto2.TYPE_BYTES) - aggregate_value: "str" = betterproto2.field(8, betterproto2.TYPE_STRING) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class UninterpretedOptionNamePart(betterproto2.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], ["moo", false] } represents - "foo.(bar.baz).moo". - """ - - name_part: "str" = betterproto2.field(1, betterproto2.TYPE_STRING) - is_extension: "bool" = betterproto2.field(2, betterproto2.TYPE_BOOL) - - -@dataclass(eq=False, repr=False, config={"extra": "forbid"}) -class Value(betterproto2.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 these - variants. Absence of any variant indicates an error. - - The JSON representation for `Value` is JSON value. - """ - - null_value: "Optional[NullValue]" = betterproto2.field( - 1, betterproto2.TYPE_ENUM, optional=True, default_factory=lambda: NullValue.try_value(0), group="kind" - ) - """ - Represents a null value. - """ - number_value: "Optional[float]" = betterproto2.field(2, betterproto2.TYPE_DOUBLE, optional=True, group="kind") - """ - Represents a double value. - """ - string_value: "Optional[str]" = betterproto2.field(3, betterproto2.TYPE_STRING, optional=True, group="kind") - """ - Represents a string value. - """ - bool_value: "Optional[bool]" = betterproto2.field(4, betterproto2.TYPE_BOOL, optional=True, group="kind") - """ - Represents a boolean value. - """ - struct_value: "Optional[Struct]" = betterproto2.field(5, betterproto2.TYPE_MESSAGE, optional=True, group="kind") - """ - Represents a structured value. - """ - list_value: "Optional[ListValue]" = betterproto2.field(6, betterproto2.TYPE_MESSAGE, optional=True, group="kind") - """ - Represents a repeated `Value`. - """ - - @model_validator(mode="after") - def check_oneof(cls, values): - return cls._validate_field_groups(values) diff --git a/src/betterproto2/lib/pydantic/google/protobuf/compiler/__init__.py b/src/betterproto2/lib/pydantic/google/protobuf/compiler/__init__.py deleted file mode 100644 index 3c51ccf4..00000000 --- a/src/betterproto2/lib/pydantic/google/protobuf/compiler/__init__.py +++ /dev/null @@ -1,205 +0,0 @@ -# Generated by the protocol buffer compiler. DO NOT EDIT! -# sources: google/protobuf/compiler/plugin.proto -# plugin: python-betterproto -# This file has been @generated - -from typing import TYPE_CHECKING - -if TYPE_CHECKING: - from dataclasses import dataclass -else: - from pydantic.dataclasses import dataclass - -from typing import List - -import betterproto2 -import betterproto2.lib.pydantic.google.protobuf as betterproto_lib_pydantic_google_protobuf - - -class CodeGeneratorResponseFeature(betterproto2.Enum): - """Sync with code_generator.h.""" - - FEATURE_NONE = 0 - FEATURE_PROTO3_OPTIONAL = 1 - FEATURE_SUPPORTS_EDITIONS = 2 - - -@dataclass(eq=False, repr=False) -class Version(betterproto2.Message): - """The version number of protocol compiler.""" - - major: int = betterproto2.int32_field(1) - minor: int = betterproto2.int32_field(2) - patch: int = betterproto2.int32_field(3) - suffix: str = betterproto2.string_field(4) - """ - A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should - be empty for mainline stable releases. - """ - - -@dataclass(eq=False, repr=False) -class CodeGeneratorRequest(betterproto2.Message): - """An encoded CodeGeneratorRequest is written to the plugin's stdin.""" - - file_to_generate: List[str] = betterproto2.string_field(1) - """ - 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. - """ - - parameter: str = betterproto2.string_field(2) - """The generator parameter passed on the command-line.""" - - proto_file: List["betterproto_lib_pydantic_google_protobuf.FileDescriptorProto"] = betterproto2.message_field(15) - """ - 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. - - Note: the files listed in files_to_generate will include runtime-retention - options only, but all other files will include source-retention options. - The source_file_descriptors field below is available in case you need - source-retention options for files_to_generate. - - 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. - """ - - source_file_descriptors: List["betterproto_lib_pydantic_google_protobuf.FileDescriptorProto"] = ( - betterproto2.message_field(17) - ) - """ - File descriptors with all options, including source-retention options. - These descriptors are only provided for the files listed in - files_to_generate. - """ - - compiler_version: "Version" = betterproto2.message_field(3) - """The version number of protocol compiler.""" - - -@dataclass(eq=False, repr=False) -class CodeGeneratorResponse(betterproto2.Message): - """The plugin writes an encoded CodeGeneratorResponse to stdout.""" - - error: str = betterproto2.string_field(1) - """ - 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: int = betterproto2.uint64_field(2) - """ - A bitmask of supported features that the code generator supports. - This is a bitwise "or" of values from the Feature enum. - """ - - minimum_edition: int = betterproto2.int32_field(3) - """ - The minimum edition this plugin supports. This will be treated as an - Edition enum, but we want to allow unknown values. It should be specified - according the edition enum value, *not* the edition number. Only takes - effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. - """ - - maximum_edition: int = betterproto2.int32_field(4) - """ - The maximum edition this plugin supports. This will be treated as an - Edition enum, but we want to allow unknown values. It should be specified - according the edition enum value, *not* the edition number. Only takes - effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. - """ - - file: List["CodeGeneratorResponseFile"] = betterproto2.message_field(15) - - -@dataclass(eq=False, repr=False) -class CodeGeneratorResponseFile(betterproto2.Message): - """Represents a single generated file.""" - - name: str = betterproto2.string_field(1) - """ - 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: str = betterproto2.string_field(2) - """ - 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: str = betterproto2.string_field(15) - """The file contents.""" - - generated_code_info: "betterproto_lib_pydantic_google_protobuf.GeneratedCodeInfo" = betterproto2.message_field(16) - """ - 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. - """ - - -CodeGeneratorRequest.__pydantic_model__.update_forward_refs() # type: ignore -CodeGeneratorResponse.__pydantic_model__.update_forward_refs() # type: ignore -CodeGeneratorResponseFile.__pydantic_model__.update_forward_refs() # type: ignore diff --git a/src/betterproto2/lib/std/__init__.py b/src/betterproto2/lib/std/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/betterproto2/lib/std/google/__init__.py b/src/betterproto2/lib/std/google/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/betterproto2/lib/std/google/protobuf/compiler/__init__.py b/src/betterproto2/lib/std/google/protobuf/compiler/__init__.py deleted file mode 100644 index 9540ade4..00000000 --- a/src/betterproto2/lib/std/google/protobuf/compiler/__init__.py +++ /dev/null @@ -1,196 +0,0 @@ -# Generated by the protocol buffer compiler. DO NOT EDIT! -# sources: google/protobuf/compiler/plugin.proto -# plugin: python-betterproto2 -# This file has been @generated - -from dataclasses import dataclass -from typing import List - -import betterproto2 -import betterproto2.lib.google.protobuf as betterproto_lib_google_protobuf - - -class CodeGeneratorResponseFeature(betterproto2.Enum): - """Sync with code_generator.h.""" - - FEATURE_NONE = 0 - FEATURE_PROTO3_OPTIONAL = 1 - FEATURE_SUPPORTS_EDITIONS = 2 - - -@dataclass(eq=False, repr=False) -class Version(betterproto2.Message): - """The version number of protocol compiler.""" - - major: int = betterproto2.int32_field(1) - minor: int = betterproto2.int32_field(2) - patch: int = betterproto2.int32_field(3) - suffix: str = betterproto2.string_field(4) - """ - A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should - be empty for mainline stable releases. - """ - - -@dataclass(eq=False, repr=False) -class CodeGeneratorRequest(betterproto2.Message): - """An encoded CodeGeneratorRequest is written to the plugin's stdin.""" - - file_to_generate: List[str] = betterproto2.string_field(1, repeated=True) - """ - 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. - """ - - parameter: str = betterproto2.string_field(2) - """The generator parameter passed on the command-line.""" - - proto_file: List["betterproto_lib_google_protobuf.FileDescriptorProto"] = betterproto2.message_field( - 15, repeated=True - ) - """ - 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. - - Note: the files listed in files_to_generate will include runtime-retention - options only, but all other files will include source-retention options. - The source_file_descriptors field below is available in case you need - source-retention options for files_to_generate. - - 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. - """ - - source_file_descriptors: List["betterproto_lib_google_protobuf.FileDescriptorProto"] = betterproto2.message_field( - 17, repeated=True - ) - """ - File descriptors with all options, including source-retention options. - These descriptors are only provided for the files listed in - files_to_generate. - """ - - compiler_version: "Version" = betterproto2.message_field(3) - """The version number of protocol compiler.""" - - -@dataclass(eq=False, repr=False) -class CodeGeneratorResponse(betterproto2.Message): - """The plugin writes an encoded CodeGeneratorResponse to stdout.""" - - error: str = betterproto2.string_field(1) - """ - 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: int = betterproto2.uint64_field(2) - """ - A bitmask of supported features that the code generator supports. - This is a bitwise "or" of values from the Feature enum. - """ - - minimum_edition: int = betterproto2.int32_field(3) - """ - The minimum edition this plugin supports. This will be treated as an - Edition enum, but we want to allow unknown values. It should be specified - according the edition enum value, *not* the edition number. Only takes - effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. - """ - - maximum_edition: int = betterproto2.int32_field(4) - """ - The maximum edition this plugin supports. This will be treated as an - Edition enum, but we want to allow unknown values. It should be specified - according the edition enum value, *not* the edition number. Only takes - effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. - """ - - file: List["CodeGeneratorResponseFile"] = betterproto2.message_field(15, repeated=True) - - -@dataclass(eq=False, repr=False) -class CodeGeneratorResponseFile(betterproto2.Message): - """Represents a single generated file.""" - - name: str = betterproto2.string_field(1) - """ - 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: str = betterproto2.string_field(2) - """ - 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: str = betterproto2.string_field(15) - """The file contents.""" - - generated_code_info: "betterproto_lib_google_protobuf.GeneratedCodeInfo" = betterproto2.message_field(16) - """ - 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. - """ diff --git a/tests/inputs/googletypes_request/test_googletypes_request.py b/tests/inputs/googletypes_request/test_googletypes_request.py index 6e32356b..8ac62854 100644 --- a/tests/inputs/googletypes_request/test_googletypes_request.py +++ b/tests/inputs/googletypes_request/test_googletypes_request.py @@ -9,7 +9,7 @@ import pytest -import betterproto2.lib.google.protobuf as protobuf +import tests.output_betterproto.google.protobuf as protobuf from tests.mocks import MockChannel from tests.output_betterproto.googletypes_request import ( Input, diff --git a/tests/inputs/googletypes_response/test_googletypes_response.py b/tests/inputs/googletypes_response/test_googletypes_response.py index 8cfa8aeb..80622dd1 100644 --- a/tests/inputs/googletypes_response/test_googletypes_response.py +++ b/tests/inputs/googletypes_response/test_googletypes_response.py @@ -6,7 +6,7 @@ import pytest -import betterproto2.lib.google.protobuf as protobuf +import tests.output_betterproto.google.protobuf as protobuf from tests.mocks import MockChannel from tests.output_betterproto.googletypes_response import ( Input, diff --git a/tests/test_any.py b/tests/test_any.py index a0db11a7..4cf619de 100644 --- a/tests/test_any.py +++ b/tests/test_any.py @@ -1,14 +1,13 @@ def test_any() -> None: # TODO using a custom message pool will no longer be necessary when the well-known types will be compiled as well - from betterproto2.lib.google.protobuf import Any from tests.output_betterproto.any import Person - from tests.output_betterproto.message_pool import default_message_pool + from tests.output_betterproto.google.protobuf import Any person = Person(first_name="John", last_name="Smith") any = Any() - any.pack(person, message_pool=default_message_pool) + any.pack(person) new_any = Any().parse(bytes(any)) - assert new_any.unpack(message_pool=default_message_pool) == person + assert new_any.unpack() == person diff --git a/tests/test_pickling.py b/tests/test_pickling.py index 76d731bf..4d2d0dd4 100644 --- a/tests/test_pickling.py +++ b/tests/test_pickling.py @@ -6,7 +6,7 @@ import cachelib -from betterproto2.lib.google import protobuf as google +from tests.output_betterproto.google import protobuf as google from tests.output_betterproto.pickling import Complex, Fe, Fi, NestedData, PickledMessage