third_party/protobuf: Update to HEAD (5f65ee6ac7)

third_party/protobuf/python/google/protobuf/internal/python_message.py

 # Protocol Buffers - Google's data interchange format
 # Copyright 2008 Google Inc.  All rights reserved.
 # https://developers.google.com/protocol-buffers/
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
@@ skipping 33 matching lines @@
 output by the protocol compiler at compile-time.
 
 The upshot of all this is that the real implementation
 details for ALL pure-Python protocol buffers are *here in
 this file*.
 """
 
 __author__ = 'robinson@google.com (Will Robinson)'
 
 from io import BytesIO
+import struct
 import sys
-import struct
 import weakref
 
 import six
 try:
   import six.moves.copyreg as copyreg
 except ImportError:
   # On some platforms, for example gMac, we run native Python because there is
   # nothing like hermetic Python. This means lesser control on the system and
   # the six.moves package may be missing (is missing on 20150321 on gMac). Be
   # extra conservative and try to load the old replacement if it fails.
-  import copy_reg as copyreg
+  try:
+    import copy_reg as copyreg  #PY26
+  except ImportError:
+    import copyreg
 
 # We use "as" to avoid name collisions with variables.
 from google.protobuf.internal import containers
 from google.protobuf.internal import decoder
 from google.protobuf.internal import encoder
 from google.protobuf.internal import enum_type_wrapper
 from google.protobuf.internal import message_listener as message_listener_mod
 from google.protobuf.internal import type_checkers
 from google.protobuf.internal import well_known_types
 from google.protobuf.internal import wire_format
 from google.protobuf import descriptor as descriptor_mod
 from google.protobuf import message as message_mod
-from google.protobuf import symbol_database
 from google.protobuf import text_format
 
 _FieldDescriptor = descriptor_mod.FieldDescriptor
 _AnyFullTypeName = 'google.protobuf.Any'
 
 
 class GeneratedProtocolMessageType(type):
 
   """Metaclass for protocol message classes created at runtime from Descriptors.
 
   We add implementations for all methods described in the Message class.  We
   also create properties to allow getting/setting all fields in the protocol
   message.  Finally, we create slots to prevent users from accidentally
   "setting" nonexistent fields in the protocol message, which then wouldn't get
   serialized / deserialized properly.
 
   The protocol compiler currently uses this metaclass to create protocol
   message classes at runtime.  Clients can also manually create their own
   classes at runtime, as in this example:
 
   mydescriptor = Descriptor(.....)
-  class MyProtoClass(Message):
-    __metaclass__ = GeneratedProtocolMessageType
-    DESCRIPTOR = mydescriptor
+  factory = symbol_database.Default()
+  factory.pool.AddDescriptor(mydescriptor)
+  MyProtoClass = factory.GetPrototype(mydescriptor)
   myproto_instance = MyProtoClass()
   myproto.foo_field = 23
   ...
-
-  The above example will not work for nested types. If you wish to include them,
-  use reflection.MakeClass() instead of manually instantiating the class in
-  order to create the appropriate class structure.
   """
 
   # Must be consistent with the protocol-compiler code in
   # proto2/compiler/internal/generator.*.
   _DESCRIPTOR_KEY = 'DESCRIPTOR'
 
   def __new__(cls, name, bases, dictionary):
     """Custom allocation for runtime-generated class types.
 
     We override __new__ because this is apparently the only place
@@ skipping 36 matching lines @@
       bases: Base classes of the class we're constructing.
         (Should be message.Message).  We ignore this field, but
         it's required by the metaclass protocol
       dictionary: The class dictionary of the class we're
         constructing.  dictionary[_DESCRIPTOR_KEY] must contain
         a Descriptor object describing this protocol message
         type.
     """
     descriptor = dictionary[GeneratedProtocolMessageType._DESCRIPTOR_KEY]
     cls._decoders_by_tag = {}
-    cls._extensions_by_name = {}
-    cls._extensions_by_number = {}
     if (descriptor.has_options and
         descriptor.GetOptions().message_set_wire_format):
       cls._decoders_by_tag[decoder.MESSAGE_SET_ITEM_TAG] = (
-          decoder.MessageSetItemDecoder(cls._extensions_by_number), None)
+          decoder.MessageSetItemDecoder(descriptor), None)
 
     # Attach stuff to each FieldDescriptor for quick lookup later on.
     for field in descriptor.fields:
       _AttachFieldHelpers(cls, field)
 
     descriptor._concrete_class = cls  # pylint: disable=protected-access
     _AddEnumValues(descriptor, cls)
     _AddInitMethod(descriptor, cls)
     _AddPropertiesForFields(descriptor, cls)
     _AddPropertiesForExtensions(descriptor, cls)
@@ skipping 195 matching lines @@
   if field.label != _FieldDescriptor.LABEL_REPEATED:
     raise ValueError('map_entry set on non-repeated field %s' % (
         field.name))
   fields_by_name = field.message_type.fields_by_name
   key_checker = type_checkers.GetTypeChecker(fields_by_name['key'])
 
   value_field = fields_by_name['value']
   if _IsMessageMapField(field):
     def MakeMessageMapDefault(message):
       return containers.MessageMap(
-          message._listener_for_children, value_field.message_type, key_checker)
+          message._listener_for_children, value_field.message_type, key_checker,
+          field.message_type)
     return MakeMessageMapDefault
   else:
     value_checker = type_checkers.GetTypeChecker(value_field)
     def MakePrimitiveMapDefault(message):
       return containers.ScalarMap(
-          message._listener_for_children, key_checker, value_checker)
+          message._listener_for_children, key_checker, value_checker,
+          field.message_type)
     return MakePrimitiveMapDefault
 
 def _DefaultValueConstructorForField(field):
   """Returns a function which returns a default value for a field.
 
   Args:
     field: FieldDescriptor object for this field.
 
   The returned function has one argument:
     message: Message instance containing this field, or a weakref proxy
@@ skipping 335 matching lines @@
   setattr(cls, property_name, property(getter, setter, doc=doc))
 
 
 def _AddPropertiesForExtensions(descriptor, cls):
   """Adds properties for all fields in this protocol message type."""
   extension_dict = descriptor.extensions_by_name
   for extension_name, extension_field in extension_dict.items():
     constant_name = extension_name.upper() + "_FIELD_NUMBER"
     setattr(cls, constant_name, extension_field.number)
 
+  # TODO(amauryfa): Migrate all users of these attributes to functions like
+  #   pool.FindExtensionByNumber(descriptor).
+  if descriptor.file is not None:
+    # TODO(amauryfa): Use cls.MESSAGE_FACTORY.pool when available.
+    pool = descriptor.file.pool
+    cls._extensions_by_number = pool._extensions_by_number[descriptor]
+    cls._extensions_by_name = pool._extensions_by_name[descriptor]
 
 def _AddStaticMethods(cls):
   # TODO(robinson): This probably needs to be thread-safe(?)
   def RegisterExtension(extension_handle):
     extension_handle.containing_type = cls.DESCRIPTOR
+    # TODO(amauryfa): Use cls.MESSAGE_FACTORY.pool when available.
+    cls.DESCRIPTOR.file.pool.AddExtensionDescriptor(extension_handle)
     _AttachFieldHelpers(cls, extension_handle)
-
-    # Try to insert our extension, failing if an extension with the same number
-    # already exists.
-    actual_handle = cls._extensions_by_number.setdefault(
-        extension_handle.number, extension_handle)
-    if actual_handle is not extension_handle:
-      raise AssertionError(
-          'Extensions "%s" and "%s" both try to extend message type "%s" with '
-          'field number %d.' %
-          (extension_handle.full_name, actual_handle.full_name,
-           cls.DESCRIPTOR.full_name, extension_handle.number))
-
-    cls._extensions_by_name[extension_handle.full_name] = extension_handle
-
-    handle = extension_handle  # avoid line wrapping
-    if _IsMessageSetExtension(handle):
-      # MessageSet extension.  Also register under type name.
-      cls._extensions_by_name[
-          extension_handle.message_type.full_name] = extension_handle
-
   cls.RegisterExtension = staticmethod(RegisterExtension)
 
   def FromString(s):
     message = cls()
     message.MergeFromString(s)
     return message
   cls.FromString = staticmethod(FromString)
 
 
 def _IsPresent(item):
@@ skipping 133 matching lines @@
   This internal method is differnt from public Any Unpack method which takes
   the target message as argument. _InternalUnpackAny method does not have
   target message type and need to find the message type in descriptor pool.
 
   Args:
     msg: An Any message to be unpacked.
 
   Returns:
     The unpacked message.
   """
+  # TODO(amauryfa): Don't use the factory of generated messages.
+  # To make Any work with custom factories, use the message factory of the
+  # parent message.
+  # pylint: disable=g-import-not-at-top
+  from google.protobuf import symbol_database
+  factory = symbol_database.Default()
+
   type_url = msg.type_url
-  db = symbol_database.Default()
 
   if not type_url:
     return None
 
   # TODO(haberman): For now we just strip the hostname.  Better logic will be
   # required.
-  type_name = type_url.split("/")[-1]
-  descriptor = db.pool.FindMessageTypeByName(type_name)
+  type_name = type_url.split('/')[-1]
+  descriptor = factory.pool.FindMessageTypeByName(type_name)
 
   if descriptor is None:
     return None
 
-  message_class = db.GetPrototype(descriptor)
+  message_class = factory.GetPrototype(descriptor)
   message = message_class()
 
   message.ParseFromString(msg.value)
   return message
 
+
 def _AddEqualsMethod(message_descriptor, cls):
   """Helper for _AddMessageMethods()."""
   def __eq__(self, other):
     if (not isinstance(other, message_mod.Message) or
         other.DESCRIPTOR != self.DESCRIPTOR):
       return False
 
     if self is other:
       return True
 
@@ skipping 257 matching lines @@
 
 
 def _AddMergeFromMethod(cls):
   LABEL_REPEATED = _FieldDescriptor.LABEL_REPEATED
   CPPTYPE_MESSAGE = _FieldDescriptor.CPPTYPE_MESSAGE
 
   def MergeFrom(self, msg):
     if not isinstance(msg, cls):
       raise TypeError(
           "Parameter to MergeFrom() must be instance of same class: "
-          "expected %s got %s." % (cls.__name__, type(msg).__name__))
+          'expected %s got %s.' % (cls.__name__, msg.__class__.__name__))
 
     assert msg is not self
     self._Modified()
 
     fields = self._fields
 
     for field, value in msg._fields.items():
       if field.label == LABEL_REPEATED:
         field_value = fields.get(field)
         if field_value is None:
@@ skipping 302 matching lines @@
   def _FindExtensionByNumber(self, number):
     """Tries to find a known extension with the field number.
 
     Args:
       number: Extension field number.
 
     Returns:
       Extension field descriptor.
     """
     return self._extended_message._extensions_by_number.get(number, None)