File size: 7,914 Bytes
065fee7 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 |
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import collections
import inspect
import logging
from google.protobuf import descriptor_pb2
from google.protobuf import descriptor_pool
from google.protobuf import message
from google.protobuf import reflection
from proto.marshal.rules.message import MessageRule
log = logging.getLogger("_FileInfo")
class _FileInfo(
collections.namedtuple(
"_FileInfo",
["descriptor", "messages", "enums", "name", "nested", "nested_enum"],
)
):
registry = {} # Mapping[str, '_FileInfo']
@classmethod
def maybe_add_descriptor(cls, filename, package):
descriptor = cls.registry.get(filename)
if not descriptor:
descriptor = cls.registry[filename] = cls(
descriptor=descriptor_pb2.FileDescriptorProto(
name=filename,
package=package,
syntax="proto3",
),
enums=collections.OrderedDict(),
messages=collections.OrderedDict(),
name=filename,
nested={},
nested_enum={},
)
return descriptor
@staticmethod
def proto_file_name(name):
return "{0}.proto".format(name.replace(".", "/"))
def _get_manifest(self, new_class):
module = inspect.getmodule(new_class)
if hasattr(module, "__protobuf__"):
return frozenset(module.__protobuf__.manifest)
return frozenset()
def _get_remaining_manifest(self, new_class):
return self._get_manifest(new_class) - {new_class.__name__}
def _calculate_salt(self, new_class, fallback):
manifest = self._get_manifest(new_class)
if manifest and new_class.__name__ not in manifest:
log.warning(
"proto-plus module {module} has a declared manifest but {class_name} is not in it".format(
module=inspect.getmodule(new_class).__name__,
class_name=new_class.__name__,
)
)
return "" if new_class.__name__ in manifest else (fallback or "").lower()
def generate_file_pb(self, new_class, fallback_salt=""):
"""Generate the descriptors for all protos in the file.
This method takes the file descriptor attached to the parent
message and generates the immutable descriptors for all of the
messages in the file descriptor. (This must be done in one fell
swoop for immutability and to resolve proto cross-referencing.)
This is run automatically when the last proto in the file is
generated, as determined by the module's __all__ tuple.
"""
pool = descriptor_pool.Default()
# Salt the filename in the descriptor.
# This allows re-use of the filename by other proto messages if
# needed (e.g. if __all__ is not used).
salt = self._calculate_salt(new_class, fallback_salt)
self.descriptor.name = "{name}.proto".format(
name="_".join([self.descriptor.name[:-6], salt]).rstrip("_"),
)
# Add the file descriptor.
pool.Add(self.descriptor)
# Adding the file descriptor to the pool created a descriptor for
# each message; go back through our wrapper messages and associate
# them with the internal protobuf version.
for full_name, proto_plus_message in self.messages.items():
# Get the descriptor from the pool, and create the protobuf
# message based on it.
descriptor = pool.FindMessageTypeByName(full_name)
pb_message = reflection.GeneratedProtocolMessageType(
descriptor.name,
(message.Message,),
{"DESCRIPTOR": descriptor, "__module__": None},
)
# Register the message with the marshal so it is wrapped
# appropriately.
#
# We do this here (rather than at class creation) because it
# is not until this point that we have an actual protobuf
# message subclass, which is what we need to use.
proto_plus_message._meta._pb = pb_message
proto_plus_message._meta.marshal.register(
pb_message, MessageRule(pb_message, proto_plus_message)
)
# Iterate over any fields on the message and, if their type
# is a message still referenced as a string, resolve the reference.
for field in proto_plus_message._meta.fields.values():
if field.message and isinstance(field.message, str):
field.message = self.messages[field.message]
elif field.enum and isinstance(field.enum, str):
field.enum = self.enums[field.enum]
# Same thing for enums
for full_name, proto_plus_enum in self.enums.items():
descriptor = pool.FindEnumTypeByName(full_name)
proto_plus_enum._meta.pb = descriptor
# We no longer need to track this file's info; remove it from
# the module's registry and from this object.
self.registry.pop(self.name)
def ready(self, new_class):
"""Return True if a file descriptor may added, False otherwise.
This determine if all the messages that we plan to create have been
created, as best as we are able.
Since messages depend on one another, we create descriptor protos
(which reference each other using strings) and wait until we have
built everything that is going to be in the module, and then
use the descriptor protos to instantiate the actual descriptors in
one fell swoop.
Args:
new_class (~.MessageMeta): The new class currently undergoing
creation.
"""
# If there are any nested descriptors that have not been assigned to
# the descriptors that should contain them, then we are not ready.
if len(self.nested) or len(self.nested_enum):
return False
# If there are any unresolved fields (fields with a composite message
# declared as a string), ensure that the corresponding message is
# declared.
for field in self.unresolved_fields:
if (field.message and field.message not in self.messages) or (
field.enum and field.enum not in self.enums
):
return False
# If the module in which this class is defined provides a
# __protobuf__ property, it may have a manifest.
#
# Do not generate the file descriptor until every member of the
# manifest has been populated.
module = inspect.getmodule(new_class)
manifest = self._get_remaining_manifest(new_class)
# We are ready if all members have been populated.
return all(hasattr(module, i) for i in manifest)
@property
def unresolved_fields(self):
"""Return fields with referencing message types as strings."""
for proto_plus_message in self.messages.values():
for field in proto_plus_message._meta.fields.values():
if (field.message and isinstance(field.message, str)) or (
field.enum and isinstance(field.enum, str)
):
yield field
|