aboutsummaryrefslogtreecommitdiff
path: root/.venv/lib/python3.12/site-packages/google/protobuf/descriptor.py
diff options
context:
space:
mode:
Diffstat (limited to '.venv/lib/python3.12/site-packages/google/protobuf/descriptor.py')
-rw-r--r--.venv/lib/python3.12/site-packages/google/protobuf/descriptor.py1511
1 files changed, 1511 insertions, 0 deletions
diff --git a/.venv/lib/python3.12/site-packages/google/protobuf/descriptor.py b/.venv/lib/python3.12/site-packages/google/protobuf/descriptor.py
new file mode 100644
index 00000000..d8c6a435
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/google/protobuf/descriptor.py
@@ -0,0 +1,1511 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc. All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Descriptors essentially contain exactly the information found in a .proto
+file, in types that make this information accessible in Python.
+"""
+
+__author__ = 'robinson@google.com (Will Robinson)'
+
+import abc
+import binascii
+import os
+import threading
+import warnings
+
+from google.protobuf.internal import api_implementation
+
+_USE_C_DESCRIPTORS = False
+if api_implementation.Type() != 'python':
+ # pylint: disable=protected-access
+ _message = api_implementation._c_module
+ # TODO: Remove this import after fix api_implementation
+ if _message is None:
+ from google.protobuf.pyext import _message
+ _USE_C_DESCRIPTORS = True
+
+
+class Error(Exception):
+ """Base error for this module."""
+
+
+class TypeTransformationError(Error):
+ """Error transforming between python proto type and corresponding C++ type."""
+
+
+if _USE_C_DESCRIPTORS:
+ # This metaclass allows to override the behavior of code like
+ # isinstance(my_descriptor, FieldDescriptor)
+ # and make it return True when the descriptor is an instance of the extension
+ # type written in C++.
+ class DescriptorMetaclass(type):
+
+ def __instancecheck__(cls, obj):
+ if super(DescriptorMetaclass, cls).__instancecheck__(obj):
+ return True
+ if isinstance(obj, cls._C_DESCRIPTOR_CLASS):
+ return True
+ return False
+else:
+ # The standard metaclass; nothing changes.
+ DescriptorMetaclass = abc.ABCMeta
+
+
+class _Lock(object):
+ """Wrapper class of threading.Lock(), which is allowed by 'with'."""
+
+ def __new__(cls):
+ self = object.__new__(cls)
+ self._lock = threading.Lock() # pylint: disable=protected-access
+ return self
+
+ def __enter__(self):
+ self._lock.acquire()
+
+ def __exit__(self, exc_type, exc_value, exc_tb):
+ self._lock.release()
+
+
+_lock = threading.Lock()
+
+
+def _Deprecated(name):
+ if _Deprecated.count > 0:
+ _Deprecated.count -= 1
+ warnings.warn(
+ 'Call to deprecated create function %s(). Note: Create unlinked '
+ 'descriptors is going to go away. Please use get/find descriptors from '
+ 'generated code or query the descriptor_pool.'
+ % name,
+ category=DeprecationWarning, stacklevel=3)
+
+# These must match the values in descriptor.proto, but we can't use them
+# directly because we sometimes need to reference them in feature helpers
+# below *during* the build of descriptor.proto.
+_FEATURESET_MESSAGE_ENCODING_DELIMITED = 2
+_FEATURESET_FIELD_PRESENCE_IMPLICIT = 2
+_FEATURESET_FIELD_PRESENCE_LEGACY_REQUIRED = 3
+_FEATURESET_REPEATED_FIELD_ENCODING_PACKED = 1
+_FEATURESET_ENUM_TYPE_CLOSED = 2
+
+# Deprecated warnings will print 100 times at most which should be enough for
+# users to notice and do not cause timeout.
+_Deprecated.count = 100
+
+
+_internal_create_key = object()
+
+
+class DescriptorBase(metaclass=DescriptorMetaclass):
+
+ """Descriptors base class.
+
+ This class is the base of all descriptor classes. It provides common options
+ related functionality.
+
+ Attributes:
+ has_options: True if the descriptor has non-default options. Usually it is
+ not necessary to read this -- just call GetOptions() which will happily
+ return the default instance. However, it's sometimes useful for
+ efficiency, and also useful inside the protobuf implementation to avoid
+ some bootstrapping issues.
+ file (FileDescriptor): Reference to file info.
+ """
+
+ if _USE_C_DESCRIPTORS:
+ # The class, or tuple of classes, that are considered as "virtual
+ # subclasses" of this descriptor class.
+ _C_DESCRIPTOR_CLASS = ()
+
+ def __init__(self, file, options, serialized_options, options_class_name):
+ """Initialize the descriptor given its options message and the name of the
+ class of the options message. The name of the class is required in case
+ the options message is None and has to be created.
+ """
+ self._features = None
+ self.file = file
+ self._options = options
+ self._loaded_options = None
+ self._options_class_name = options_class_name
+ self._serialized_options = serialized_options
+
+ # Does this descriptor have non-default options?
+ self.has_options = (self._options is not None) or (
+ self._serialized_options is not None
+ )
+
+ @property
+ @abc.abstractmethod
+ def _parent(self):
+ pass
+
+ def _InferLegacyFeatures(self, edition, options, features):
+ """Infers features from proto2/proto3 syntax so that editions logic can be used everywhere.
+
+ Args:
+ edition: The edition to infer features for.
+ options: The options for this descriptor that are being processed.
+ features: The feature set object to modify with inferred features.
+ """
+ pass
+
+ def _GetFeatures(self):
+ if not self._features:
+ self._LazyLoadOptions()
+ return self._features
+
+ def _ResolveFeatures(self, edition, raw_options):
+ """Resolves features from the raw options of this descriptor.
+
+ Args:
+ edition: The edition to use for feature defaults.
+ raw_options: The options for this descriptor that are being processed.
+
+ Returns:
+ A fully resolved feature set for making runtime decisions.
+ """
+ # pylint: disable=g-import-not-at-top
+ from google.protobuf import descriptor_pb2
+
+ if self._parent:
+ features = descriptor_pb2.FeatureSet()
+ features.CopyFrom(self._parent._GetFeatures())
+ else:
+ features = self.file.pool._CreateDefaultFeatures(edition)
+ unresolved = descriptor_pb2.FeatureSet()
+ unresolved.CopyFrom(raw_options.features)
+ self._InferLegacyFeatures(edition, raw_options, unresolved)
+ features.MergeFrom(unresolved)
+
+ # Use the feature cache to reduce memory bloat.
+ return self.file.pool._InternFeatures(features)
+
+ def _LazyLoadOptions(self):
+ """Lazily initializes descriptor options towards the end of the build."""
+ if self._loaded_options:
+ return
+
+ # pylint: disable=g-import-not-at-top
+ from google.protobuf import descriptor_pb2
+
+ if not hasattr(descriptor_pb2, self._options_class_name):
+ raise RuntimeError(
+ 'Unknown options class name %s!' % self._options_class_name
+ )
+ options_class = getattr(descriptor_pb2, self._options_class_name)
+ features = None
+ edition = self.file._edition
+
+ if not self.has_options:
+ if not self._features:
+ features = self._ResolveFeatures(
+ descriptor_pb2.Edition.Value(edition), options_class()
+ )
+ with _lock:
+ self._loaded_options = options_class()
+ if not self._features:
+ self._features = features
+ else:
+ if not self._serialized_options:
+ options = self._options
+ else:
+ options = _ParseOptions(options_class(), self._serialized_options)
+
+ if not self._features:
+ features = self._ResolveFeatures(
+ descriptor_pb2.Edition.Value(edition), options
+ )
+ with _lock:
+ self._loaded_options = options
+ if not self._features:
+ self._features = features
+ if options.HasField('features'):
+ options.ClearField('features')
+ if not options.SerializeToString():
+ self._loaded_options = options_class()
+ self.has_options = False
+
+ def GetOptions(self):
+ """Retrieves descriptor options.
+
+ Returns:
+ The options set on this descriptor.
+ """
+ if not self._loaded_options:
+ self._LazyLoadOptions()
+ return self._loaded_options
+
+
+class _NestedDescriptorBase(DescriptorBase):
+ """Common class for descriptors that can be nested."""
+
+ def __init__(self, options, options_class_name, name, full_name,
+ file, containing_type, serialized_start=None,
+ serialized_end=None, serialized_options=None):
+ """Constructor.
+
+ Args:
+ options: Protocol message options or None to use default message options.
+ options_class_name (str): The class name of the above options.
+ name (str): Name of this protocol message type.
+ full_name (str): Fully-qualified name of this protocol message type, which
+ will include protocol "package" name and the name of any enclosing
+ types.
+ containing_type: if provided, this is a nested descriptor, with this
+ descriptor as parent, otherwise None.
+ serialized_start: The start index (inclusive) in block in the
+ file.serialized_pb that describes this descriptor.
+ serialized_end: The end index (exclusive) in block in the
+ file.serialized_pb that describes this descriptor.
+ serialized_options: Protocol message serialized options or None.
+ """
+ super(_NestedDescriptorBase, self).__init__(
+ file, options, serialized_options, options_class_name
+ )
+
+ self.name = name
+ # TODO: Add function to calculate full_name instead of having it in
+ # memory?
+ self.full_name = full_name
+ self.containing_type = containing_type
+
+ self._serialized_start = serialized_start
+ self._serialized_end = serialized_end
+
+ def CopyToProto(self, proto):
+ """Copies this to the matching proto in descriptor_pb2.
+
+ Args:
+ proto: An empty proto instance from descriptor_pb2.
+
+ Raises:
+ Error: If self couldn't be serialized, due to to few constructor
+ arguments.
+ """
+ if (self.file is not None and
+ self._serialized_start is not None and
+ self._serialized_end is not None):
+ proto.ParseFromString(self.file.serialized_pb[
+ self._serialized_start:self._serialized_end])
+ else:
+ raise Error('Descriptor does not contain serialization.')
+
+
+class Descriptor(_NestedDescriptorBase):
+
+ """Descriptor for a protocol message type.
+
+ Attributes:
+ name (str): Name of this protocol message type.
+ full_name (str): Fully-qualified name of this protocol message type,
+ which will include protocol "package" name and the name of any
+ enclosing types.
+ containing_type (Descriptor): Reference to the descriptor of the type
+ containing us, or None if this is top-level.
+ fields (list[FieldDescriptor]): Field descriptors for all fields in
+ this type.
+ fields_by_number (dict(int, FieldDescriptor)): Same
+ :class:`FieldDescriptor` objects as in :attr:`fields`, but indexed
+ by "number" attribute in each FieldDescriptor.
+ fields_by_name (dict(str, FieldDescriptor)): Same
+ :class:`FieldDescriptor` objects as in :attr:`fields`, but indexed by
+ "name" attribute in each :class:`FieldDescriptor`.
+ nested_types (list[Descriptor]): Descriptor references
+ for all protocol message types nested within this one.
+ nested_types_by_name (dict(str, Descriptor)): Same Descriptor
+ objects as in :attr:`nested_types`, but indexed by "name" attribute
+ in each Descriptor.
+ enum_types (list[EnumDescriptor]): :class:`EnumDescriptor` references
+ for all enums contained within this type.
+ enum_types_by_name (dict(str, EnumDescriptor)): Same
+ :class:`EnumDescriptor` objects as in :attr:`enum_types`, but
+ indexed by "name" attribute in each EnumDescriptor.
+ enum_values_by_name (dict(str, EnumValueDescriptor)): Dict mapping
+ from enum value name to :class:`EnumValueDescriptor` for that value.
+ extensions (list[FieldDescriptor]): All extensions defined directly
+ within this message type (NOT within a nested type).
+ extensions_by_name (dict(str, FieldDescriptor)): Same FieldDescriptor
+ objects as :attr:`extensions`, but indexed by "name" attribute of each
+ FieldDescriptor.
+ is_extendable (bool): Does this type define any extension ranges?
+ oneofs (list[OneofDescriptor]): The list of descriptors for oneof fields
+ in this message.
+ oneofs_by_name (dict(str, OneofDescriptor)): Same objects as in
+ :attr:`oneofs`, but indexed by "name" attribute.
+ file (FileDescriptor): Reference to file descriptor.
+ is_map_entry: If the message type is a map entry.
+
+ """
+
+ if _USE_C_DESCRIPTORS:
+ _C_DESCRIPTOR_CLASS = _message.Descriptor
+
+ def __new__(
+ cls,
+ name=None,
+ full_name=None,
+ filename=None,
+ containing_type=None,
+ fields=None,
+ nested_types=None,
+ enum_types=None,
+ extensions=None,
+ options=None,
+ serialized_options=None,
+ is_extendable=True,
+ extension_ranges=None,
+ oneofs=None,
+ file=None, # pylint: disable=redefined-builtin
+ serialized_start=None,
+ serialized_end=None,
+ syntax=None,
+ is_map_entry=False,
+ create_key=None):
+ _message.Message._CheckCalledFromGeneratedFile()
+ return _message.default_pool.FindMessageTypeByName(full_name)
+
+ # NOTE: The file argument redefining a builtin is nothing we can
+ # fix right now since we don't know how many clients already rely on the
+ # name of the argument.
+ def __init__(self, name, full_name, filename, containing_type, fields,
+ nested_types, enum_types, extensions, options=None,
+ serialized_options=None,
+ is_extendable=True, extension_ranges=None, oneofs=None,
+ file=None, serialized_start=None, serialized_end=None, # pylint: disable=redefined-builtin
+ syntax=None, is_map_entry=False, create_key=None):
+ """Arguments to __init__() are as described in the description
+ of Descriptor fields above.
+
+ Note that filename is an obsolete argument, that is not used anymore.
+ Please use file.name to access this as an attribute.
+ """
+ if create_key is not _internal_create_key:
+ _Deprecated('Descriptor')
+
+ super(Descriptor, self).__init__(
+ options, 'MessageOptions', name, full_name, file,
+ containing_type, serialized_start=serialized_start,
+ serialized_end=serialized_end, serialized_options=serialized_options)
+
+ # We have fields in addition to fields_by_name and fields_by_number,
+ # so that:
+ # 1. Clients can index fields by "order in which they're listed."
+ # 2. Clients can easily iterate over all fields with the terse
+ # syntax: for f in descriptor.fields: ...
+ self.fields = fields
+ for field in self.fields:
+ field.containing_type = self
+ field.file = file
+ self.fields_by_number = dict((f.number, f) for f in fields)
+ self.fields_by_name = dict((f.name, f) for f in fields)
+ self._fields_by_camelcase_name = None
+
+ self.nested_types = nested_types
+ for nested_type in nested_types:
+ nested_type.containing_type = self
+ self.nested_types_by_name = dict((t.name, t) for t in nested_types)
+
+ self.enum_types = enum_types
+ for enum_type in self.enum_types:
+ enum_type.containing_type = self
+ self.enum_types_by_name = dict((t.name, t) for t in enum_types)
+ self.enum_values_by_name = dict(
+ (v.name, v) for t in enum_types for v in t.values)
+
+ self.extensions = extensions
+ for extension in self.extensions:
+ extension.extension_scope = self
+ self.extensions_by_name = dict((f.name, f) for f in extensions)
+ self.is_extendable = is_extendable
+ self.extension_ranges = extension_ranges
+ self.oneofs = oneofs if oneofs is not None else []
+ self.oneofs_by_name = dict((o.name, o) for o in self.oneofs)
+ for oneof in self.oneofs:
+ oneof.containing_type = self
+ oneof.file = file
+ self._is_map_entry = is_map_entry
+
+ @property
+ def _parent(self):
+ return self.containing_type or self.file
+
+ @property
+ def fields_by_camelcase_name(self):
+ """Same FieldDescriptor objects as in :attr:`fields`, but indexed by
+ :attr:`FieldDescriptor.camelcase_name`.
+ """
+ if self._fields_by_camelcase_name is None:
+ self._fields_by_camelcase_name = dict(
+ (f.camelcase_name, f) for f in self.fields)
+ return self._fields_by_camelcase_name
+
+ def EnumValueName(self, enum, value):
+ """Returns the string name of an enum value.
+
+ This is just a small helper method to simplify a common operation.
+
+ Args:
+ enum: string name of the Enum.
+ value: int, value of the enum.
+
+ Returns:
+ string name of the enum value.
+
+ Raises:
+ KeyError if either the Enum doesn't exist or the value is not a valid
+ value for the enum.
+ """
+ return self.enum_types_by_name[enum].values_by_number[value].name
+
+ def CopyToProto(self, proto):
+ """Copies this to a descriptor_pb2.DescriptorProto.
+
+ Args:
+ proto: An empty descriptor_pb2.DescriptorProto.
+ """
+ # This function is overridden to give a better doc comment.
+ super(Descriptor, self).CopyToProto(proto)
+
+
+# TODO: We should have aggressive checking here,
+# for example:
+# * If you specify a repeated field, you should not be allowed
+# to specify a default value.
+# * [Other examples here as needed].
+#
+# TODO: for this and other *Descriptor classes, we
+# might also want to lock things down aggressively (e.g.,
+# prevent clients from setting the attributes). Having
+# stronger invariants here in general will reduce the number
+# of runtime checks we must do in reflection.py...
+class FieldDescriptor(DescriptorBase):
+
+ """Descriptor for a single field in a .proto file.
+
+ Attributes:
+ name (str): Name of this field, exactly as it appears in .proto.
+ full_name (str): Name of this field, including containing scope. This is
+ particularly relevant for extensions.
+ index (int): Dense, 0-indexed index giving the order that this
+ field textually appears within its message in the .proto file.
+ number (int): Tag number declared for this field in the .proto file.
+
+ type (int): (One of the TYPE_* constants below) Declared type.
+ cpp_type (int): (One of the CPPTYPE_* constants below) C++ type used to
+ represent this field.
+
+ label (int): (One of the LABEL_* constants below) Tells whether this
+ field is optional, required, or repeated.
+ has_default_value (bool): True if this field has a default value defined,
+ otherwise false.
+ default_value (Varies): Default value of this field. Only
+ meaningful for non-repeated scalar fields. Repeated fields
+ should always set this to [], and non-repeated composite
+ fields should always set this to None.
+
+ containing_type (Descriptor): Descriptor of the protocol message
+ type that contains this field. Set by the Descriptor constructor
+ if we're passed into one.
+ Somewhat confusingly, for extension fields, this is the
+ descriptor of the EXTENDED message, not the descriptor
+ of the message containing this field. (See is_extension and
+ extension_scope below).
+ message_type (Descriptor): If a composite field, a descriptor
+ of the message type contained in this field. Otherwise, this is None.
+ enum_type (EnumDescriptor): If this field contains an enum, a
+ descriptor of that enum. Otherwise, this is None.
+
+ is_extension: True iff this describes an extension field.
+ extension_scope (Descriptor): Only meaningful if is_extension is True.
+ Gives the message that immediately contains this extension field.
+ Will be None iff we're a top-level (file-level) extension field.
+
+ options (descriptor_pb2.FieldOptions): Protocol message field options or
+ None to use default field options.
+
+ containing_oneof (OneofDescriptor): If the field is a member of a oneof
+ union, contains its descriptor. Otherwise, None.
+
+ file (FileDescriptor): Reference to file descriptor.
+ """
+
+ # Must be consistent with C++ FieldDescriptor::Type enum in
+ # descriptor.h.
+ #
+ # TODO: Find a way to eliminate this repetition.
+ TYPE_DOUBLE = 1
+ TYPE_FLOAT = 2
+ TYPE_INT64 = 3
+ TYPE_UINT64 = 4
+ TYPE_INT32 = 5
+ TYPE_FIXED64 = 6
+ TYPE_FIXED32 = 7
+ TYPE_BOOL = 8
+ TYPE_STRING = 9
+ TYPE_GROUP = 10
+ TYPE_MESSAGE = 11
+ TYPE_BYTES = 12
+ TYPE_UINT32 = 13
+ TYPE_ENUM = 14
+ TYPE_SFIXED32 = 15
+ TYPE_SFIXED64 = 16
+ TYPE_SINT32 = 17
+ TYPE_SINT64 = 18
+ MAX_TYPE = 18
+
+ # Must be consistent with C++ FieldDescriptor::CppType enum in
+ # descriptor.h.
+ #
+ # TODO: Find a way to eliminate this repetition.
+ CPPTYPE_INT32 = 1
+ CPPTYPE_INT64 = 2
+ CPPTYPE_UINT32 = 3
+ CPPTYPE_UINT64 = 4
+ CPPTYPE_DOUBLE = 5
+ CPPTYPE_FLOAT = 6
+ CPPTYPE_BOOL = 7
+ CPPTYPE_ENUM = 8
+ CPPTYPE_STRING = 9
+ CPPTYPE_MESSAGE = 10
+ MAX_CPPTYPE = 10
+
+ _PYTHON_TO_CPP_PROTO_TYPE_MAP = {
+ TYPE_DOUBLE: CPPTYPE_DOUBLE,
+ TYPE_FLOAT: CPPTYPE_FLOAT,
+ TYPE_ENUM: CPPTYPE_ENUM,
+ TYPE_INT64: CPPTYPE_INT64,
+ TYPE_SINT64: CPPTYPE_INT64,
+ TYPE_SFIXED64: CPPTYPE_INT64,
+ TYPE_UINT64: CPPTYPE_UINT64,
+ TYPE_FIXED64: CPPTYPE_UINT64,
+ TYPE_INT32: CPPTYPE_INT32,
+ TYPE_SFIXED32: CPPTYPE_INT32,
+ TYPE_SINT32: CPPTYPE_INT32,
+ TYPE_UINT32: CPPTYPE_UINT32,
+ TYPE_FIXED32: CPPTYPE_UINT32,
+ TYPE_BYTES: CPPTYPE_STRING,
+ TYPE_STRING: CPPTYPE_STRING,
+ TYPE_BOOL: CPPTYPE_BOOL,
+ TYPE_MESSAGE: CPPTYPE_MESSAGE,
+ TYPE_GROUP: CPPTYPE_MESSAGE
+ }
+
+ # Must be consistent with C++ FieldDescriptor::Label enum in
+ # descriptor.h.
+ #
+ # TODO: Find a way to eliminate this repetition.
+ LABEL_OPTIONAL = 1
+ LABEL_REQUIRED = 2
+ LABEL_REPEATED = 3
+ MAX_LABEL = 3
+
+ # Must be consistent with C++ constants kMaxNumber, kFirstReservedNumber,
+ # and kLastReservedNumber in descriptor.h
+ MAX_FIELD_NUMBER = (1 << 29) - 1
+ FIRST_RESERVED_FIELD_NUMBER = 19000
+ LAST_RESERVED_FIELD_NUMBER = 19999
+
+ if _USE_C_DESCRIPTORS:
+ _C_DESCRIPTOR_CLASS = _message.FieldDescriptor
+
+ def __new__(cls, name, full_name, index, number, type, cpp_type, label,
+ default_value, message_type, enum_type, containing_type,
+ is_extension, extension_scope, options=None,
+ serialized_options=None,
+ has_default_value=True, containing_oneof=None, json_name=None,
+ file=None, create_key=None): # pylint: disable=redefined-builtin
+ _message.Message._CheckCalledFromGeneratedFile()
+ if is_extension:
+ return _message.default_pool.FindExtensionByName(full_name)
+ else:
+ return _message.default_pool.FindFieldByName(full_name)
+
+ def __init__(self, name, full_name, index, number, type, cpp_type, label,
+ default_value, message_type, enum_type, containing_type,
+ is_extension, extension_scope, options=None,
+ serialized_options=None,
+ has_default_value=True, containing_oneof=None, json_name=None,
+ file=None, create_key=None): # pylint: disable=redefined-builtin
+ """The arguments are as described in the description of FieldDescriptor
+ attributes above.
+
+ Note that containing_type may be None, and may be set later if necessary
+ (to deal with circular references between message types, for example).
+ Likewise for extension_scope.
+ """
+ if create_key is not _internal_create_key:
+ _Deprecated('FieldDescriptor')
+
+ super(FieldDescriptor, self).__init__(
+ file, options, serialized_options, 'FieldOptions'
+ )
+ self.name = name
+ self.full_name = full_name
+ self._camelcase_name = None
+ if json_name is None:
+ self.json_name = _ToJsonName(name)
+ else:
+ self.json_name = json_name
+ self.index = index
+ self.number = number
+ self._type = type
+ self.cpp_type = cpp_type
+ self._label = label
+ self.has_default_value = has_default_value
+ self.default_value = default_value
+ self.containing_type = containing_type
+ self.message_type = message_type
+ self.enum_type = enum_type
+ self.is_extension = is_extension
+ self.extension_scope = extension_scope
+ self.containing_oneof = containing_oneof
+ if api_implementation.Type() == 'python':
+ self._cdescriptor = None
+ else:
+ if is_extension:
+ self._cdescriptor = _message.default_pool.FindExtensionByName(full_name)
+ else:
+ self._cdescriptor = _message.default_pool.FindFieldByName(full_name)
+
+ @property
+ def _parent(self):
+ if self.containing_oneof:
+ return self.containing_oneof
+ if self.is_extension:
+ return self.extension_scope or self.file
+ return self.containing_type
+
+ def _InferLegacyFeatures(self, edition, options, features):
+ # pylint: disable=g-import-not-at-top
+ from google.protobuf import descriptor_pb2
+
+ if edition >= descriptor_pb2.Edition.EDITION_2023:
+ return
+
+ if self._label == FieldDescriptor.LABEL_REQUIRED:
+ features.field_presence = (
+ descriptor_pb2.FeatureSet.FieldPresence.LEGACY_REQUIRED
+ )
+
+ if self._type == FieldDescriptor.TYPE_GROUP:
+ features.message_encoding = (
+ descriptor_pb2.FeatureSet.MessageEncoding.DELIMITED
+ )
+
+ if options.HasField('packed'):
+ features.repeated_field_encoding = (
+ descriptor_pb2.FeatureSet.RepeatedFieldEncoding.PACKED
+ if options.packed
+ else descriptor_pb2.FeatureSet.RepeatedFieldEncoding.EXPANDED
+ )
+
+ @property
+ def type(self):
+ if (
+ self._GetFeatures().message_encoding
+ == _FEATURESET_MESSAGE_ENCODING_DELIMITED
+ and self.message_type
+ and not self.message_type.GetOptions().map_entry
+ and not self.containing_type.GetOptions().map_entry
+ ):
+ return FieldDescriptor.TYPE_GROUP
+ return self._type
+
+ @type.setter
+ def type(self, val):
+ self._type = val
+
+ @property
+ def label(self):
+ if (
+ self._GetFeatures().field_presence
+ == _FEATURESET_FIELD_PRESENCE_LEGACY_REQUIRED
+ ):
+ return FieldDescriptor.LABEL_REQUIRED
+ return self._label
+
+ @property
+ def camelcase_name(self):
+ """Camelcase name of this field.
+
+ Returns:
+ str: the name in CamelCase.
+ """
+ if self._camelcase_name is None:
+ self._camelcase_name = _ToCamelCase(self.name)
+ return self._camelcase_name
+
+ @property
+ def has_presence(self):
+ """Whether the field distinguishes between unpopulated and default values.
+
+ Raises:
+ RuntimeError: singular field that is not linked with message nor file.
+ """
+ if self.label == FieldDescriptor.LABEL_REPEATED:
+ return False
+ if (
+ self.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE
+ or self.is_extension
+ or self.containing_oneof
+ ):
+ return True
+
+ return (
+ self._GetFeatures().field_presence
+ != _FEATURESET_FIELD_PRESENCE_IMPLICIT
+ )
+
+ @property
+ def is_packed(self):
+ """Returns if the field is packed."""
+ if self.label != FieldDescriptor.LABEL_REPEATED:
+ return False
+ field_type = self.type
+ if (field_type == FieldDescriptor.TYPE_STRING or
+ field_type == FieldDescriptor.TYPE_GROUP or
+ field_type == FieldDescriptor.TYPE_MESSAGE or
+ field_type == FieldDescriptor.TYPE_BYTES):
+ return False
+
+ return (
+ self._GetFeatures().repeated_field_encoding
+ == _FEATURESET_REPEATED_FIELD_ENCODING_PACKED
+ )
+
+ @staticmethod
+ def ProtoTypeToCppProtoType(proto_type):
+ """Converts from a Python proto type to a C++ Proto Type.
+
+ The Python ProtocolBuffer classes specify both the 'Python' datatype and the
+ 'C++' datatype - and they're not the same. This helper method should
+ translate from one to another.
+
+ Args:
+ proto_type: the Python proto type (descriptor.FieldDescriptor.TYPE_*)
+ Returns:
+ int: descriptor.FieldDescriptor.CPPTYPE_*, the C++ type.
+ Raises:
+ TypeTransformationError: when the Python proto type isn't known.
+ """
+ try:
+ return FieldDescriptor._PYTHON_TO_CPP_PROTO_TYPE_MAP[proto_type]
+ except KeyError:
+ raise TypeTransformationError('Unknown proto_type: %s' % proto_type)
+
+
+class EnumDescriptor(_NestedDescriptorBase):
+
+ """Descriptor for an enum defined in a .proto file.
+
+ Attributes:
+ name (str): Name of the enum type.
+ full_name (str): Full name of the type, including package name
+ and any enclosing type(s).
+
+ values (list[EnumValueDescriptor]): List of the values
+ in this enum.
+ values_by_name (dict(str, EnumValueDescriptor)): Same as :attr:`values`,
+ but indexed by the "name" field of each EnumValueDescriptor.
+ values_by_number (dict(int, EnumValueDescriptor)): Same as :attr:`values`,
+ but indexed by the "number" field of each EnumValueDescriptor.
+ containing_type (Descriptor): Descriptor of the immediate containing
+ type of this enum, or None if this is an enum defined at the
+ top level in a .proto file. Set by Descriptor's constructor
+ if we're passed into one.
+ file (FileDescriptor): Reference to file descriptor.
+ options (descriptor_pb2.EnumOptions): Enum options message or
+ None to use default enum options.
+ """
+
+ if _USE_C_DESCRIPTORS:
+ _C_DESCRIPTOR_CLASS = _message.EnumDescriptor
+
+ def __new__(cls, name, full_name, filename, values,
+ containing_type=None, options=None,
+ serialized_options=None, file=None, # pylint: disable=redefined-builtin
+ serialized_start=None, serialized_end=None, create_key=None):
+ _message.Message._CheckCalledFromGeneratedFile()
+ return _message.default_pool.FindEnumTypeByName(full_name)
+
+ def __init__(self, name, full_name, filename, values,
+ containing_type=None, options=None,
+ serialized_options=None, file=None, # pylint: disable=redefined-builtin
+ serialized_start=None, serialized_end=None, create_key=None):
+ """Arguments are as described in the attribute description above.
+
+ Note that filename is an obsolete argument, that is not used anymore.
+ Please use file.name to access this as an attribute.
+ """
+ if create_key is not _internal_create_key:
+ _Deprecated('EnumDescriptor')
+
+ super(EnumDescriptor, self).__init__(
+ options, 'EnumOptions', name, full_name, file,
+ containing_type, serialized_start=serialized_start,
+ serialized_end=serialized_end, serialized_options=serialized_options)
+
+ self.values = values
+ for value in self.values:
+ value.file = file
+ value.type = self
+ self.values_by_name = dict((v.name, v) for v in values)
+ # Values are reversed to ensure that the first alias is retained.
+ self.values_by_number = dict((v.number, v) for v in reversed(values))
+
+ @property
+ def _parent(self):
+ return self.containing_type or self.file
+
+ @property
+ def is_closed(self):
+ """Returns true whether this is a "closed" enum.
+
+ This means that it:
+ - Has a fixed set of values, rather than being equivalent to an int32.
+ - Encountering values not in this set causes them to be treated as unknown
+ fields.
+ - The first value (i.e., the default) may be nonzero.
+
+ WARNING: Some runtimes currently have a quirk where non-closed enums are
+ treated as closed when used as the type of fields defined in a
+ `syntax = proto2;` file. This quirk is not present in all runtimes; as of
+ writing, we know that:
+
+ - C++, Java, and C++-based Python share this quirk.
+ - UPB and UPB-based Python do not.
+ - PHP and Ruby treat all enums as open regardless of declaration.
+
+ Care should be taken when using this function to respect the target
+ runtime's enum handling quirks.
+ """
+ return self._GetFeatures().enum_type == _FEATURESET_ENUM_TYPE_CLOSED
+
+ def CopyToProto(self, proto):
+ """Copies this to a descriptor_pb2.EnumDescriptorProto.
+
+ Args:
+ proto (descriptor_pb2.EnumDescriptorProto): An empty descriptor proto.
+ """
+ # This function is overridden to give a better doc comment.
+ super(EnumDescriptor, self).CopyToProto(proto)
+
+
+class EnumValueDescriptor(DescriptorBase):
+
+ """Descriptor for a single value within an enum.
+
+ Attributes:
+ name (str): Name of this value.
+ index (int): Dense, 0-indexed index giving the order that this
+ value appears textually within its enum in the .proto file.
+ number (int): Actual number assigned to this enum value.
+ type (EnumDescriptor): :class:`EnumDescriptor` to which this value
+ belongs. Set by :class:`EnumDescriptor`'s constructor if we're
+ passed into one.
+ options (descriptor_pb2.EnumValueOptions): Enum value options message or
+ None to use default enum value options options.
+ """
+
+ if _USE_C_DESCRIPTORS:
+ _C_DESCRIPTOR_CLASS = _message.EnumValueDescriptor
+
+ def __new__(cls, name, index, number,
+ type=None, # pylint: disable=redefined-builtin
+ options=None, serialized_options=None, create_key=None):
+ _message.Message._CheckCalledFromGeneratedFile()
+ # There is no way we can build a complete EnumValueDescriptor with the
+ # given parameters (the name of the Enum is not known, for example).
+ # Fortunately generated files just pass it to the EnumDescriptor()
+ # constructor, which will ignore it, so returning None is good enough.
+ return None
+
+ def __init__(self, name, index, number,
+ type=None, # pylint: disable=redefined-builtin
+ options=None, serialized_options=None, create_key=None):
+ """Arguments are as described in the attribute description above."""
+ if create_key is not _internal_create_key:
+ _Deprecated('EnumValueDescriptor')
+
+ super(EnumValueDescriptor, self).__init__(
+ type.file if type else None,
+ options,
+ serialized_options,
+ 'EnumValueOptions',
+ )
+ self.name = name
+ self.index = index
+ self.number = number
+ self.type = type
+
+ @property
+ def _parent(self):
+ return self.type
+
+
+class OneofDescriptor(DescriptorBase):
+ """Descriptor for a oneof field.
+
+ Attributes:
+ name (str): Name of the oneof field.
+ full_name (str): Full name of the oneof field, including package name.
+ index (int): 0-based index giving the order of the oneof field inside
+ its containing type.
+ containing_type (Descriptor): :class:`Descriptor` of the protocol message
+ type that contains this field. Set by the :class:`Descriptor` constructor
+ if we're passed into one.
+ fields (list[FieldDescriptor]): The list of field descriptors this
+ oneof can contain.
+ """
+
+ if _USE_C_DESCRIPTORS:
+ _C_DESCRIPTOR_CLASS = _message.OneofDescriptor
+
+ def __new__(
+ cls, name, full_name, index, containing_type, fields, options=None,
+ serialized_options=None, create_key=None):
+ _message.Message._CheckCalledFromGeneratedFile()
+ return _message.default_pool.FindOneofByName(full_name)
+
+ def __init__(
+ self, name, full_name, index, containing_type, fields, options=None,
+ serialized_options=None, create_key=None):
+ """Arguments are as described in the attribute description above."""
+ if create_key is not _internal_create_key:
+ _Deprecated('OneofDescriptor')
+
+ super(OneofDescriptor, self).__init__(
+ containing_type.file if containing_type else None,
+ options,
+ serialized_options,
+ 'OneofOptions',
+ )
+ self.name = name
+ self.full_name = full_name
+ self.index = index
+ self.containing_type = containing_type
+ self.fields = fields
+
+ @property
+ def _parent(self):
+ return self.containing_type
+
+
+class ServiceDescriptor(_NestedDescriptorBase):
+
+ """Descriptor for a service.
+
+ Attributes:
+ name (str): Name of the service.
+ full_name (str): Full name of the service, including package name.
+ index (int): 0-indexed index giving the order that this services
+ definition appears within the .proto file.
+ methods (list[MethodDescriptor]): List of methods provided by this
+ service.
+ methods_by_name (dict(str, MethodDescriptor)): Same
+ :class:`MethodDescriptor` objects as in :attr:`methods_by_name`, but
+ indexed by "name" attribute in each :class:`MethodDescriptor`.
+ options (descriptor_pb2.ServiceOptions): Service options message or
+ None to use default service options.
+ file (FileDescriptor): Reference to file info.
+ """
+
+ if _USE_C_DESCRIPTORS:
+ _C_DESCRIPTOR_CLASS = _message.ServiceDescriptor
+
+ def __new__(
+ cls,
+ name=None,
+ full_name=None,
+ index=None,
+ methods=None,
+ options=None,
+ serialized_options=None,
+ file=None, # pylint: disable=redefined-builtin
+ serialized_start=None,
+ serialized_end=None,
+ create_key=None):
+ _message.Message._CheckCalledFromGeneratedFile() # pylint: disable=protected-access
+ return _message.default_pool.FindServiceByName(full_name)
+
+ def __init__(self, name, full_name, index, methods, options=None,
+ serialized_options=None, file=None, # pylint: disable=redefined-builtin
+ serialized_start=None, serialized_end=None, create_key=None):
+ if create_key is not _internal_create_key:
+ _Deprecated('ServiceDescriptor')
+
+ super(ServiceDescriptor, self).__init__(
+ options, 'ServiceOptions', name, full_name, file,
+ None, serialized_start=serialized_start,
+ serialized_end=serialized_end, serialized_options=serialized_options)
+ self.index = index
+ self.methods = methods
+ self.methods_by_name = dict((m.name, m) for m in methods)
+ # Set the containing service for each method in this service.
+ for method in self.methods:
+ method.file = self.file
+ method.containing_service = self
+
+ @property
+ def _parent(self):
+ return self.file
+
+ def FindMethodByName(self, name):
+ """Searches for the specified method, and returns its descriptor.
+
+ Args:
+ name (str): Name of the method.
+
+ Returns:
+ MethodDescriptor: The descriptor for the requested method.
+
+ Raises:
+ KeyError: if the method cannot be found in the service.
+ """
+ return self.methods_by_name[name]
+
+ def CopyToProto(self, proto):
+ """Copies this to a descriptor_pb2.ServiceDescriptorProto.
+
+ Args:
+ proto (descriptor_pb2.ServiceDescriptorProto): An empty descriptor proto.
+ """
+ # This function is overridden to give a better doc comment.
+ super(ServiceDescriptor, self).CopyToProto(proto)
+
+
+class MethodDescriptor(DescriptorBase):
+
+ """Descriptor for a method in a service.
+
+ Attributes:
+ name (str): Name of the method within the service.
+ full_name (str): Full name of method.
+ index (int): 0-indexed index of the method inside the service.
+ containing_service (ServiceDescriptor): The service that contains this
+ method.
+ input_type (Descriptor): The descriptor of the message that this method
+ accepts.
+ output_type (Descriptor): The descriptor of the message that this method
+ returns.
+ client_streaming (bool): Whether this method uses client streaming.
+ server_streaming (bool): Whether this method uses server streaming.
+ options (descriptor_pb2.MethodOptions or None): Method options message, or
+ None to use default method options.
+ """
+
+ if _USE_C_DESCRIPTORS:
+ _C_DESCRIPTOR_CLASS = _message.MethodDescriptor
+
+ def __new__(cls,
+ name,
+ full_name,
+ index,
+ containing_service,
+ input_type,
+ output_type,
+ client_streaming=False,
+ server_streaming=False,
+ options=None,
+ serialized_options=None,
+ create_key=None):
+ _message.Message._CheckCalledFromGeneratedFile() # pylint: disable=protected-access
+ return _message.default_pool.FindMethodByName(full_name)
+
+ def __init__(self,
+ name,
+ full_name,
+ index,
+ containing_service,
+ input_type,
+ output_type,
+ client_streaming=False,
+ server_streaming=False,
+ options=None,
+ serialized_options=None,
+ create_key=None):
+ """The arguments are as described in the description of MethodDescriptor
+ attributes above.
+
+ Note that containing_service may be None, and may be set later if necessary.
+ """
+ if create_key is not _internal_create_key:
+ _Deprecated('MethodDescriptor')
+
+ super(MethodDescriptor, self).__init__(
+ containing_service.file if containing_service else None,
+ options,
+ serialized_options,
+ 'MethodOptions',
+ )
+ self.name = name
+ self.full_name = full_name
+ self.index = index
+ self.containing_service = containing_service
+ self.input_type = input_type
+ self.output_type = output_type
+ self.client_streaming = client_streaming
+ self.server_streaming = server_streaming
+
+ @property
+ def _parent(self):
+ return self.containing_service
+
+ def CopyToProto(self, proto):
+ """Copies this to a descriptor_pb2.MethodDescriptorProto.
+
+ Args:
+ proto (descriptor_pb2.MethodDescriptorProto): An empty descriptor proto.
+
+ Raises:
+ Error: If self couldn't be serialized, due to too few constructor
+ arguments.
+ """
+ if self.containing_service is not None:
+ from google.protobuf import descriptor_pb2
+ service_proto = descriptor_pb2.ServiceDescriptorProto()
+ self.containing_service.CopyToProto(service_proto)
+ proto.CopyFrom(service_proto.method[self.index])
+ else:
+ raise Error('Descriptor does not contain a service.')
+
+
+class FileDescriptor(DescriptorBase):
+ """Descriptor for a file. Mimics the descriptor_pb2.FileDescriptorProto.
+
+ Note that :attr:`enum_types_by_name`, :attr:`extensions_by_name`, and
+ :attr:`dependencies` fields are only set by the
+ :py:mod:`google.protobuf.message_factory` module, and not by the generated
+ proto code.
+
+ Attributes:
+ name (str): Name of file, relative to root of source tree.
+ package (str): Name of the package
+ edition (Edition): Enum value indicating edition of the file
+ serialized_pb (bytes): Byte string of serialized
+ :class:`descriptor_pb2.FileDescriptorProto`.
+ dependencies (list[FileDescriptor]): List of other :class:`FileDescriptor`
+ objects this :class:`FileDescriptor` depends on.
+ public_dependencies (list[FileDescriptor]): A subset of
+ :attr:`dependencies`, which were declared as "public".
+ message_types_by_name (dict(str, Descriptor)): Mapping from message names to
+ their :class:`Descriptor`.
+ enum_types_by_name (dict(str, EnumDescriptor)): Mapping from enum names to
+ their :class:`EnumDescriptor`.
+ extensions_by_name (dict(str, FieldDescriptor)): Mapping from extension
+ names declared at file scope to their :class:`FieldDescriptor`.
+ services_by_name (dict(str, ServiceDescriptor)): Mapping from services'
+ names to their :class:`ServiceDescriptor`.
+ pool (DescriptorPool): The pool this descriptor belongs to. When not passed
+ to the constructor, the global default pool is used.
+ """
+
+ if _USE_C_DESCRIPTORS:
+ _C_DESCRIPTOR_CLASS = _message.FileDescriptor
+
+ def __new__(
+ cls,
+ name,
+ package,
+ options=None,
+ serialized_options=None,
+ serialized_pb=None,
+ dependencies=None,
+ public_dependencies=None,
+ syntax=None,
+ edition=None,
+ pool=None,
+ create_key=None,
+ ):
+ # FileDescriptor() is called from various places, not only from generated
+ # files, to register dynamic proto files and messages.
+ # pylint: disable=g-explicit-bool-comparison
+ if serialized_pb:
+ return _message.default_pool.AddSerializedFile(serialized_pb)
+ else:
+ return super(FileDescriptor, cls).__new__(cls)
+
+ def __init__(
+ self,
+ name,
+ package,
+ options=None,
+ serialized_options=None,
+ serialized_pb=None,
+ dependencies=None,
+ public_dependencies=None,
+ syntax=None,
+ edition=None,
+ pool=None,
+ create_key=None,
+ ):
+ """Constructor."""
+ if create_key is not _internal_create_key:
+ _Deprecated('FileDescriptor')
+
+ super(FileDescriptor, self).__init__(
+ self, options, serialized_options, 'FileOptions'
+ )
+
+ if edition and edition != 'EDITION_UNKNOWN':
+ self._edition = edition
+ elif syntax == 'proto3':
+ self._edition = 'EDITION_PROTO3'
+ else:
+ self._edition = 'EDITION_PROTO2'
+
+ if pool is None:
+ from google.protobuf import descriptor_pool
+ pool = descriptor_pool.Default()
+ self.pool = pool
+ self.message_types_by_name = {}
+ self.name = name
+ self.package = package
+ self.serialized_pb = serialized_pb
+
+ self.enum_types_by_name = {}
+ self.extensions_by_name = {}
+ self.services_by_name = {}
+ self.dependencies = (dependencies or [])
+ self.public_dependencies = (public_dependencies or [])
+
+ def CopyToProto(self, proto):
+ """Copies this to a descriptor_pb2.FileDescriptorProto.
+
+ Args:
+ proto: An empty descriptor_pb2.FileDescriptorProto.
+ """
+ proto.ParseFromString(self.serialized_pb)
+
+ @property
+ def _parent(self):
+ return None
+
+
+def _ParseOptions(message, string):
+ """Parses serialized options.
+
+ This helper function is used to parse serialized options in generated
+ proto2 files. It must not be used outside proto2.
+ """
+ message.ParseFromString(string)
+ return message
+
+
+def _ToCamelCase(name):
+ """Converts name to camel-case and returns it."""
+ capitalize_next = False
+ result = []
+
+ for c in name:
+ if c == '_':
+ if result:
+ capitalize_next = True
+ elif capitalize_next:
+ result.append(c.upper())
+ capitalize_next = False
+ else:
+ result += c
+
+ # Lower-case the first letter.
+ if result and result[0].isupper():
+ result[0] = result[0].lower()
+ return ''.join(result)
+
+
+def _OptionsOrNone(descriptor_proto):
+ """Returns the value of the field `options`, or None if it is not set."""
+ if descriptor_proto.HasField('options'):
+ return descriptor_proto.options
+ else:
+ return None
+
+
+def _ToJsonName(name):
+ """Converts name to Json name and returns it."""
+ capitalize_next = False
+ result = []
+
+ for c in name:
+ if c == '_':
+ capitalize_next = True
+ elif capitalize_next:
+ result.append(c.upper())
+ capitalize_next = False
+ else:
+ result += c
+
+ return ''.join(result)
+
+
+def MakeDescriptor(
+ desc_proto,
+ package='',
+ build_file_if_cpp=True,
+ syntax=None,
+ edition=None,
+ file_desc=None,
+):
+ """Make a protobuf Descriptor given a DescriptorProto protobuf.
+
+ Handles nested descriptors. Note that this is limited to the scope of defining
+ a message inside of another message. Composite fields can currently only be
+ resolved if the message is defined in the same scope as the field.
+
+ Args:
+ desc_proto: The descriptor_pb2.DescriptorProto protobuf message.
+ package: Optional package name for the new message Descriptor (string).
+ build_file_if_cpp: Update the C++ descriptor pool if api matches. Set to
+ False on recursion, so no duplicates are created.
+ syntax: The syntax/semantics that should be used. Set to "proto3" to get
+ proto3 field presence semantics.
+ edition: The edition that should be used if syntax is "edition".
+ file_desc: A FileDescriptor to place this descriptor into.
+
+ Returns:
+ A Descriptor for protobuf messages.
+ """
+ # pylint: disable=g-import-not-at-top
+ from google.protobuf import descriptor_pb2
+
+ # Generate a random name for this proto file to prevent conflicts with any
+ # imported ones. We need to specify a file name so the descriptor pool
+ # accepts our FileDescriptorProto, but it is not important what that file
+ # name is actually set to.
+ proto_name = binascii.hexlify(os.urandom(16)).decode('ascii')
+
+ if package:
+ file_name = os.path.join(package.replace('.', '/'), proto_name + '.proto')
+ else:
+ file_name = proto_name + '.proto'
+
+ if api_implementation.Type() != 'python' and build_file_if_cpp:
+ # The C++ implementation requires all descriptors to be backed by the same
+ # definition in the C++ descriptor pool. To do this, we build a
+ # FileDescriptorProto with the same definition as this descriptor and build
+ # it into the pool.
+ file_descriptor_proto = descriptor_pb2.FileDescriptorProto()
+ file_descriptor_proto.message_type.add().MergeFrom(desc_proto)
+
+ if package:
+ file_descriptor_proto.package = package
+ file_descriptor_proto.name = file_name
+
+ _message.default_pool.Add(file_descriptor_proto)
+ result = _message.default_pool.FindFileByName(file_descriptor_proto.name)
+
+ if _USE_C_DESCRIPTORS:
+ return result.message_types_by_name[desc_proto.name]
+
+ if file_desc is None:
+ file_desc = FileDescriptor(
+ pool=None,
+ name=file_name,
+ package=package,
+ syntax=syntax,
+ edition=edition,
+ options=None,
+ serialized_pb='',
+ dependencies=[],
+ public_dependencies=[],
+ create_key=_internal_create_key,
+ )
+ full_message_name = [desc_proto.name]
+ if package: full_message_name.insert(0, package)
+
+ # Create Descriptors for enum types
+ enum_types = {}
+ for enum_proto in desc_proto.enum_type:
+ full_name = '.'.join(full_message_name + [enum_proto.name])
+ enum_desc = EnumDescriptor(
+ enum_proto.name,
+ full_name,
+ None,
+ [
+ EnumValueDescriptor(
+ enum_val.name,
+ ii,
+ enum_val.number,
+ create_key=_internal_create_key,
+ )
+ for ii, enum_val in enumerate(enum_proto.value)
+ ],
+ file=file_desc,
+ create_key=_internal_create_key,
+ )
+ enum_types[full_name] = enum_desc
+
+ # Create Descriptors for nested types
+ nested_types = {}
+ for nested_proto in desc_proto.nested_type:
+ full_name = '.'.join(full_message_name + [nested_proto.name])
+ # Nested types are just those defined inside of the message, not all types
+ # used by fields in the message, so no loops are possible here.
+ nested_desc = MakeDescriptor(
+ nested_proto,
+ package='.'.join(full_message_name),
+ build_file_if_cpp=False,
+ syntax=syntax,
+ edition=edition,
+ file_desc=file_desc,
+ )
+ nested_types[full_name] = nested_desc
+
+ fields = []
+ for field_proto in desc_proto.field:
+ full_name = '.'.join(full_message_name + [field_proto.name])
+ enum_desc = None
+ nested_desc = None
+ if field_proto.json_name:
+ json_name = field_proto.json_name
+ else:
+ json_name = None
+ if field_proto.HasField('type_name'):
+ type_name = field_proto.type_name
+ full_type_name = '.'.join(full_message_name +
+ [type_name[type_name.rfind('.')+1:]])
+ if full_type_name in nested_types:
+ nested_desc = nested_types[full_type_name]
+ elif full_type_name in enum_types:
+ enum_desc = enum_types[full_type_name]
+ # Else type_name references a non-local type, which isn't implemented
+ field = FieldDescriptor(
+ field_proto.name,
+ full_name,
+ field_proto.number - 1,
+ field_proto.number,
+ field_proto.type,
+ FieldDescriptor.ProtoTypeToCppProtoType(field_proto.type),
+ field_proto.label,
+ None,
+ nested_desc,
+ enum_desc,
+ None,
+ False,
+ None,
+ options=_OptionsOrNone(field_proto),
+ has_default_value=False,
+ json_name=json_name,
+ file=file_desc,
+ create_key=_internal_create_key,
+ )
+ fields.append(field)
+
+ desc_name = '.'.join(full_message_name)
+ return Descriptor(
+ desc_proto.name,
+ desc_name,
+ None,
+ None,
+ fields,
+ list(nested_types.values()),
+ list(enum_types.values()),
+ [],
+ options=_OptionsOrNone(desc_proto),
+ file=file_desc,
+ create_key=_internal_create_key,
+ )