@uns-kit/cli 0.0.51 → 0.0.53

package/templates/python/venv/lib/python3.12/site-packages/google/protobuf/descriptor.py

@@ -1,1524 +0,0 @@
-# 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 is_required(self):
-    """Returns if the field is required."""
-    return (
-        self._GetFeatures().field_presence
-        == _FEATURESET_FIELD_PRESENCE_LEGACY_REQUIRED
-    )
-
-  @property
-  def is_repeated(self):
-    """Returns if the field is repeated."""
-    return self._label == FieldDescriptor.LABEL_REPEATED
-
-  @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.is_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 not self.is_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,
-  )