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"""Provides a factory class for generating dynamic messages. 32 33The easiest way to use this class is if you have access to the FileDescriptor 34protos containing the messages you want to create you can just do the following: 35 36message_classes = message_factory.GetMessages(iterable_of_file_descriptors) 37my_proto_instance = message_classes['some.proto.package.MessageName']() 38""" 39 40__author__ = '[email protected] (Matt Toia)' 41 42from google.protobuf.internal import api_implementation 43from google.protobuf import descriptor_pool 44from google.protobuf import message 45 46if api_implementation.Type() == 'python': 47 from google.protobuf.internal import python_message as message_impl 48else: 49 from google.protobuf.pyext import cpp_message as message_impl # pylint: disable=g-import-not-at-top 50 51 52# The type of all Message classes. 53_GENERATED_PROTOCOL_MESSAGE_TYPE = message_impl.GeneratedProtocolMessageType 54 55 56class MessageFactory(object): 57 """Factory for creating Proto2 messages from descriptors in a pool.""" 58 59 def __init__(self, pool=None): 60 """Initializes a new factory.""" 61 self.pool = pool or descriptor_pool.DescriptorPool() 62 63 # local cache of all classes built from protobuf descriptors 64 self._classes = {} 65 66 def GetPrototype(self, descriptor): 67 """Obtains a proto2 message class based on the passed in descriptor. 68 69 Passing a descriptor with a fully qualified name matching a previous 70 invocation will cause the same class to be returned. 71 72 Args: 73 descriptor: The descriptor to build from. 74 75 Returns: 76 A class describing the passed in descriptor. 77 """ 78 if descriptor not in self._classes: 79 result_class = self.CreatePrototype(descriptor) 80 # The assignment to _classes is redundant for the base implementation, but 81 # might avoid confusion in cases where CreatePrototype gets overridden and 82 # does not call the base implementation. 83 self._classes[descriptor] = result_class 84 return result_class 85 return self._classes[descriptor] 86 87 def CreatePrototype(self, descriptor): 88 """Builds a proto2 message class based on the passed in descriptor. 89 90 Don't call this function directly, it always creates a new class. Call 91 GetPrototype() instead. This method is meant to be overridden in subblasses 92 to perform additional operations on the newly constructed class. 93 94 Args: 95 descriptor: The descriptor to build from. 96 97 Returns: 98 A class describing the passed in descriptor. 99 """ 100 descriptor_name = descriptor.name 101 result_class = _GENERATED_PROTOCOL_MESSAGE_TYPE( 102 descriptor_name, 103 (message.Message,), 104 { 105 'DESCRIPTOR': descriptor, 106 # If module not set, it wrongly points to message_factory module. 107 '__module__': None, 108 }) 109 result_class._FACTORY = self # pylint: disable=protected-access 110 # Assign in _classes before doing recursive calls to avoid infinite 111 # recursion. 112 self._classes[descriptor] = result_class 113 for field in descriptor.fields: 114 if field.message_type: 115 self.GetPrototype(field.message_type) 116 for extension in result_class.DESCRIPTOR.extensions: 117 if extension.containing_type not in self._classes: 118 self.GetPrototype(extension.containing_type) 119 extended_class = self._classes[extension.containing_type] 120 extended_class.RegisterExtension(extension) 121 if extension.message_type: 122 self.GetPrototype(extension.message_type) 123 return result_class 124 125 def GetMessages(self, files): 126 """Gets all the messages from a specified file. 127 128 This will find and resolve dependencies, failing if the descriptor 129 pool cannot satisfy them. 130 131 Args: 132 files: The file names to extract messages from. 133 134 Returns: 135 A dictionary mapping proto names to the message classes. This will include 136 any dependent messages as well as any messages defined in the same file as 137 a specified message. 138 """ 139 result = {} 140 for file_name in files: 141 file_desc = self.pool.FindFileByName(file_name) 142 for desc in file_desc.message_types_by_name.values(): 143 result[desc.full_name] = self.GetPrototype(desc) 144 145 # While the extension FieldDescriptors are created by the descriptor pool, 146 # the python classes created in the factory need them to be registered 147 # explicitly, which is done below. 148 # 149 # The call to RegisterExtension will specifically check if the 150 # extension was already registered on the object and either 151 # ignore the registration if the original was the same, or raise 152 # an error if they were different. 153 154 for extension in file_desc.extensions_by_name.values(): 155 if extension.containing_type not in self._classes: 156 self.GetPrototype(extension.containing_type) 157 extended_class = self._classes[extension.containing_type] 158 extended_class.RegisterExtension(extension) 159 if extension.message_type: 160 self.GetPrototype(extension.message_type) 161 return result 162 163 164_FACTORY = MessageFactory() 165 166 167def GetMessages(file_protos): 168 """Builds a dictionary of all the messages available in a set of files. 169 170 Args: 171 file_protos: Iterable of FileDescriptorProto to build messages out of. 172 173 Returns: 174 A dictionary mapping proto names to the message classes. This will include 175 any dependent messages as well as any messages defined in the same file as 176 a specified message. 177 """ 178 # The cpp implementation of the protocol buffer library requires to add the 179 # message in topological order of the dependency graph. 180 file_by_name = {file_proto.name: file_proto for file_proto in file_protos} 181 def _AddFile(file_proto): 182 for dependency in file_proto.dependency: 183 if dependency in file_by_name: 184 # Remove from elements to be visited, in order to cut cycles. 185 _AddFile(file_by_name.pop(dependency)) 186 _FACTORY.pool.Add(file_proto) 187 while file_by_name: 188 _AddFile(file_by_name.popitem()[1]) 189 return _FACTORY.GetMessages([file_proto.name for file_proto in file_protos]) 190