Home | History | Annotate | Download | only in protobuf 
      1 # Protocol Buffers - Google's data interchange format
      2 # Copyright 2008 Google Inc.  All rights reserved.
      3 # https://developers.google.com/protocol-buffers/
      4 #
      5 # Redistribution and use in source and binary forms, with or without
      6 # modification, are permitted provided that the following conditions are
      7 # met:
      8 #
      9 #     * Redistributions of source code must retain the above copyright
     10 # notice, this list of conditions and the following disclaimer.
     11 #     * Redistributions in binary form must reproduce the above
     12 # copyright notice, this list of conditions and the following disclaimer
     13 # in the documentation and/or other materials provided with the
     14 # distribution.
     15 #     * Neither the name of Google Inc. nor the names of its
     16 # contributors may be used to endorse or promote products derived from
     17 # this software without specific prior written permission.
     18 #
     19 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     20 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     21 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     22 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     23 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     24 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     25 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     26 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     27 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     28 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     29 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     30 
     31 #PY25 compatible for GAE.
     32 #
     33 # Copyright 2012 Google Inc. All Rights Reserved.
     34 
     35 """Provides a factory class for generating dynamic messages.
     36 
     37 The easiest way to use this class is if you have access to the FileDescriptor
     38 protos containing the messages you want to create you can just do the following:
     39 
     40 message_classes = message_factory.GetMessages(iterable_of_file_descriptors)
     41 my_proto_instance = message_classes['some.proto.package.MessageName']()
     42 """
     43 
     44 __author__ = 'matthewtoia (at] google.com (Matt Toia)'
     45 
     46 import sys  ##PY25
     47 from google.protobuf import descriptor_database
     48 from google.protobuf import descriptor_pool
     49 from google.protobuf import message
     50 from google.protobuf import reflection
     51 
     52 
     53 class MessageFactory(object):
     54   """Factory for creating Proto2 messages from descriptors in a pool."""
     55 
     56   def __init__(self, pool=None):
     57     """Initializes a new factory."""
     58     self.pool = (pool or descriptor_pool.DescriptorPool(
     59         descriptor_database.DescriptorDatabase()))
     60 
     61     # local cache of all classes built from protobuf descriptors
     62     self._classes = {}
     63 
     64   def GetPrototype(self, descriptor):
     65     """Builds a proto2 message class based on the passed in descriptor.
     66 
     67     Passing a descriptor with a fully qualified name matching a previous
     68     invocation will cause the same class to be returned.
     69 
     70     Args:
     71       descriptor: The descriptor to build from.
     72 
     73     Returns:
     74       A class describing the passed in descriptor.
     75     """
     76     if descriptor.full_name not in self._classes:
     77       descriptor_name = descriptor.name
     78       if sys.version_info[0] < 3:  ##PY25
     79 ##!PY25      if str is bytes:  # PY2
     80         descriptor_name = descriptor.name.encode('ascii', 'ignore')
     81       result_class = reflection.GeneratedProtocolMessageType(
     82           descriptor_name,
     83           (message.Message,),
     84           {'DESCRIPTOR': descriptor, '__module__': None})
     85           # If module not set, it wrongly points to the reflection.py module.
     86       self._classes[descriptor.full_name] = result_class
     87       for field in descriptor.fields:
     88         if field.message_type:
     89           self.GetPrototype(field.message_type)
     90       for extension in result_class.DESCRIPTOR.extensions:
     91         if extension.containing_type.full_name not in self._classes:
     92           self.GetPrototype(extension.containing_type)
     93         extended_class = self._classes[extension.containing_type.full_name]
     94         extended_class.RegisterExtension(extension)
     95     return self._classes[descriptor.full_name]
     96 
     97   def GetMessages(self, files):
     98     """Gets all the messages from a specified file.
     99 
    100     This will find and resolve dependencies, failing if the descriptor
    101     pool cannot satisfy them.
    102 
    103     Args:
    104       files: The file names to extract messages from.
    105 
    106     Returns:
    107       A dictionary mapping proto names to the message classes. This will include
    108       any dependent messages as well as any messages defined in the same file as
    109       a specified message.
    110     """
    111     result = {}
    112     for file_name in files:
    113       file_desc = self.pool.FindFileByName(file_name)
    114       for name, msg in file_desc.message_types_by_name.iteritems():
    115         if file_desc.package:
    116           full_name = '.'.join([file_desc.package, name])
    117         else:
    118           full_name = msg.name
    119         result[full_name] = self.GetPrototype(
    120             self.pool.FindMessageTypeByName(full_name))
    121 
    122       # While the extension FieldDescriptors are created by the descriptor pool,
    123       # the python classes created in the factory need them to be registered
    124       # explicitly, which is done below.
    125       #
    126       # The call to RegisterExtension will specifically check if the
    127       # extension was already registered on the object and either
    128       # ignore the registration if the original was the same, or raise
    129       # an error if they were different.
    130 
    131       for name, extension in file_desc.extensions_by_name.iteritems():
    132         if extension.containing_type.full_name not in self._classes:
    133           self.GetPrototype(extension.containing_type)
    134         extended_class = self._classes[extension.containing_type.full_name]
    135         extended_class.RegisterExtension(extension)
    136     return result
    137 
    138 
    139 _FACTORY = MessageFactory()
    140 
    141 
    142 def GetMessages(file_protos):
    143   """Builds a dictionary of all the messages available in a set of files.
    144 
    145   Args:
    146     file_protos: A sequence of file protos to build messages out of.
    147 
    148   Returns:
    149     A dictionary mapping proto names to the message classes. This will include
    150     any dependent messages as well as any messages defined in the same file as
    151     a specified message.
    152   """
    153   for file_proto in file_protos:
    154     _FACTORY.pool.Add(file_proto)
    155   return _FACTORY.GetMessages([file_proto.name for file_proto in file_protos])
    156