OLD | NEW |
(Empty) | |
| 1 # Protocol Buffers - Google's data interchange format |
| 2 # Copyright 2008 Google Inc. All rights reserved. |
| 3 # http://code.google.com/p/protobuf/ |
| 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 DescriptorPool to use as a container for proto2 descriptors. |
| 32 |
| 33 The DescriptorPool is used in conjection with a DescriptorDatabase to maintain |
| 34 a collection of protocol buffer descriptors for use when dynamically creating |
| 35 message types at runtime. |
| 36 |
| 37 For most applications protocol buffers should be used via modules generated by |
| 38 the protocol buffer compiler tool. This should only be used when the type of |
| 39 protocol buffers used in an application or library cannot be predetermined. |
| 40 |
| 41 Below is a straightforward example on how to use this class: |
| 42 |
| 43 pool = DescriptorPool() |
| 44 file_descriptor_protos = [ ... ] |
| 45 for file_descriptor_proto in file_descriptor_protos: |
| 46 pool.Add(file_descriptor_proto) |
| 47 my_message_descriptor = pool.FindMessageTypeByName('some.package.MessageType') |
| 48 |
| 49 The message descriptor can be used in conjunction with the message_factory |
| 50 module in order to create a protocol buffer class that can be encoded and |
| 51 decoded. |
| 52 |
| 53 If you want to get a Python class for the specified proto, use the |
| 54 helper functions inside google.protobuf.message_factory |
| 55 directly instead of this class. |
| 56 """ |
| 57 |
| 58 __author__ = 'matthewtoia@google.com (Matt Toia)' |
| 59 |
| 60 import sys |
| 61 |
| 62 from google.protobuf import descriptor |
| 63 from google.protobuf import descriptor_database |
| 64 from google.protobuf import text_encoding |
| 65 |
| 66 |
| 67 def _NormalizeFullyQualifiedName(name): |
| 68 """Remove leading period from fully-qualified type name. |
| 69 |
| 70 Due to b/13860351 in descriptor_database.py, types in the root namespace are |
| 71 generated with a leading period. This function removes that prefix. |
| 72 |
| 73 Args: |
| 74 name: A str, the fully-qualified symbol name. |
| 75 |
| 76 Returns: |
| 77 A str, the normalized fully-qualified symbol name. |
| 78 """ |
| 79 return name.lstrip('.') |
| 80 |
| 81 |
| 82 class DescriptorPool(object): |
| 83 """A collection of protobufs dynamically constructed by descriptor protos.""" |
| 84 |
| 85 def __init__(self, descriptor_db=None): |
| 86 """Initializes a Pool of proto buffs. |
| 87 |
| 88 The descriptor_db argument to the constructor is provided to allow |
| 89 specialized file descriptor proto lookup code to be triggered on demand. An |
| 90 example would be an implementation which will read and compile a file |
| 91 specified in a call to FindFileByName() and not require the call to Add() |
| 92 at all. Results from this database will be cached internally here as well. |
| 93 |
| 94 Args: |
| 95 descriptor_db: A secondary source of file descriptors. |
| 96 """ |
| 97 |
| 98 self._internal_db = descriptor_database.DescriptorDatabase() |
| 99 self._descriptor_db = descriptor_db |
| 100 self._descriptors = {} |
| 101 self._enum_descriptors = {} |
| 102 self._file_descriptors = {} |
| 103 |
| 104 def Add(self, file_desc_proto): |
| 105 """Adds the FileDescriptorProto and its types to this pool. |
| 106 |
| 107 Args: |
| 108 file_desc_proto: The FileDescriptorProto to add. |
| 109 """ |
| 110 |
| 111 self._internal_db.Add(file_desc_proto) |
| 112 |
| 113 def AddDescriptor(self, desc): |
| 114 """Adds a Descriptor to the pool, non-recursively. |
| 115 |
| 116 If the Descriptor contains nested messages or enums, the caller must |
| 117 explicitly register them. This method also registers the FileDescriptor |
| 118 associated with the message. |
| 119 |
| 120 Args: |
| 121 desc: A Descriptor. |
| 122 """ |
| 123 if not isinstance(desc, descriptor.Descriptor): |
| 124 raise TypeError('Expected instance of descriptor.Descriptor.') |
| 125 |
| 126 self._descriptors[desc.full_name] = desc |
| 127 self.AddFileDescriptor(desc.file) |
| 128 |
| 129 def AddEnumDescriptor(self, enum_desc): |
| 130 """Adds an EnumDescriptor to the pool. |
| 131 |
| 132 This method also registers the FileDescriptor associated with the message. |
| 133 |
| 134 Args: |
| 135 enum_desc: An EnumDescriptor. |
| 136 """ |
| 137 |
| 138 if not isinstance(enum_desc, descriptor.EnumDescriptor): |
| 139 raise TypeError('Expected instance of descriptor.EnumDescriptor.') |
| 140 |
| 141 self._enum_descriptors[enum_desc.full_name] = enum_desc |
| 142 self.AddFileDescriptor(enum_desc.file) |
| 143 |
| 144 def AddFileDescriptor(self, file_desc): |
| 145 """Adds a FileDescriptor to the pool, non-recursively. |
| 146 |
| 147 If the FileDescriptor contains messages or enums, the caller must explicitly |
| 148 register them. |
| 149 |
| 150 Args: |
| 151 file_desc: A FileDescriptor. |
| 152 """ |
| 153 |
| 154 if not isinstance(file_desc, descriptor.FileDescriptor): |
| 155 raise TypeError('Expected instance of descriptor.FileDescriptor.') |
| 156 self._file_descriptors[file_desc.name] = file_desc |
| 157 |
| 158 def FindFileByName(self, file_name): |
| 159 """Gets a FileDescriptor by file name. |
| 160 |
| 161 Args: |
| 162 file_name: The path to the file to get a descriptor for. |
| 163 |
| 164 Returns: |
| 165 A FileDescriptor for the named file. |
| 166 |
| 167 Raises: |
| 168 KeyError: if the file can not be found in the pool. |
| 169 """ |
| 170 |
| 171 try: |
| 172 return self._file_descriptors[file_name] |
| 173 except KeyError: |
| 174 pass |
| 175 |
| 176 try: |
| 177 file_proto = self._internal_db.FindFileByName(file_name) |
| 178 except KeyError: |
| 179 _, error, _ = sys.exc_info() #PY25 compatible for GAE. |
| 180 if self._descriptor_db: |
| 181 file_proto = self._descriptor_db.FindFileByName(file_name) |
| 182 else: |
| 183 raise error |
| 184 if not file_proto: |
| 185 raise KeyError('Cannot find a file named %s' % file_name) |
| 186 return self._ConvertFileProtoToFileDescriptor(file_proto) |
| 187 |
| 188 def FindFileContainingSymbol(self, symbol): |
| 189 """Gets the FileDescriptor for the file containing the specified symbol. |
| 190 |
| 191 Args: |
| 192 symbol: The name of the symbol to search for. |
| 193 |
| 194 Returns: |
| 195 A FileDescriptor that contains the specified symbol. |
| 196 |
| 197 Raises: |
| 198 KeyError: if the file can not be found in the pool. |
| 199 """ |
| 200 |
| 201 symbol = _NormalizeFullyQualifiedName(symbol) |
| 202 try: |
| 203 return self._descriptors[symbol].file |
| 204 except KeyError: |
| 205 pass |
| 206 |
| 207 try: |
| 208 return self._enum_descriptors[symbol].file |
| 209 except KeyError: |
| 210 pass |
| 211 |
| 212 try: |
| 213 file_proto = self._internal_db.FindFileContainingSymbol(symbol) |
| 214 except KeyError: |
| 215 _, error, _ = sys.exc_info() #PY25 compatible for GAE. |
| 216 if self._descriptor_db: |
| 217 file_proto = self._descriptor_db.FindFileContainingSymbol(symbol) |
| 218 else: |
| 219 raise error |
| 220 if not file_proto: |
| 221 raise KeyError('Cannot find a file containing %s' % symbol) |
| 222 return self._ConvertFileProtoToFileDescriptor(file_proto) |
| 223 |
| 224 def FindMessageTypeByName(self, full_name): |
| 225 """Loads the named descriptor from the pool. |
| 226 |
| 227 Args: |
| 228 full_name: The full name of the descriptor to load. |
| 229 |
| 230 Returns: |
| 231 The descriptor for the named type. |
| 232 """ |
| 233 |
| 234 full_name = _NormalizeFullyQualifiedName(full_name) |
| 235 if full_name not in self._descriptors: |
| 236 self.FindFileContainingSymbol(full_name) |
| 237 return self._descriptors[full_name] |
| 238 |
| 239 def FindEnumTypeByName(self, full_name): |
| 240 """Loads the named enum descriptor from the pool. |
| 241 |
| 242 Args: |
| 243 full_name: The full name of the enum descriptor to load. |
| 244 |
| 245 Returns: |
| 246 The enum descriptor for the named type. |
| 247 """ |
| 248 |
| 249 full_name = _NormalizeFullyQualifiedName(full_name) |
| 250 if full_name not in self._enum_descriptors: |
| 251 self.FindFileContainingSymbol(full_name) |
| 252 return self._enum_descriptors[full_name] |
| 253 |
| 254 def _ConvertFileProtoToFileDescriptor(self, file_proto): |
| 255 """Creates a FileDescriptor from a proto or returns a cached copy. |
| 256 |
| 257 This method also has the side effect of loading all the symbols found in |
| 258 the file into the appropriate dictionaries in the pool. |
| 259 |
| 260 Args: |
| 261 file_proto: The proto to convert. |
| 262 |
| 263 Returns: |
| 264 A FileDescriptor matching the passed in proto. |
| 265 """ |
| 266 |
| 267 if file_proto.name not in self._file_descriptors: |
| 268 built_deps = list(self._GetDeps(file_proto.dependency)) |
| 269 direct_deps = [self.FindFileByName(n) for n in file_proto.dependency] |
| 270 |
| 271 file_descriptor = descriptor.FileDescriptor( |
| 272 name=file_proto.name, |
| 273 package=file_proto.package, |
| 274 options=file_proto.options, |
| 275 serialized_pb=file_proto.SerializeToString(), |
| 276 dependencies=direct_deps) |
| 277 scope = {} |
| 278 |
| 279 # This loop extracts all the message and enum types from all the |
| 280 # dependencoes of the file_proto. This is necessary to create the |
| 281 # scope of available message types when defining the passed in |
| 282 # file proto. |
| 283 for dependency in built_deps: |
| 284 scope.update(self._ExtractSymbols( |
| 285 dependency.message_types_by_name.values())) |
| 286 scope.update((_PrefixWithDot(enum.full_name), enum) |
| 287 for enum in dependency.enum_types_by_name.values()) |
| 288 |
| 289 for message_type in file_proto.message_type: |
| 290 message_desc = self._ConvertMessageDescriptor( |
| 291 message_type, file_proto.package, file_descriptor, scope) |
| 292 file_descriptor.message_types_by_name[message_desc.name] = message_desc |
| 293 |
| 294 for enum_type in file_proto.enum_type: |
| 295 file_descriptor.enum_types_by_name[enum_type.name] = ( |
| 296 self._ConvertEnumDescriptor(enum_type, file_proto.package, |
| 297 file_descriptor, None, scope)) |
| 298 |
| 299 for index, extension_proto in enumerate(file_proto.extension): |
| 300 extension_desc = self.MakeFieldDescriptor( |
| 301 extension_proto, file_proto.package, index, is_extension=True) |
| 302 extension_desc.containing_type = self._GetTypeFromScope( |
| 303 file_descriptor.package, extension_proto.extendee, scope) |
| 304 self.SetFieldType(extension_proto, extension_desc, |
| 305 file_descriptor.package, scope) |
| 306 file_descriptor.extensions_by_name[extension_desc.name] = extension_desc |
| 307 |
| 308 for desc_proto in file_proto.message_type: |
| 309 self.SetAllFieldTypes(file_proto.package, desc_proto, scope) |
| 310 |
| 311 if file_proto.package: |
| 312 desc_proto_prefix = _PrefixWithDot(file_proto.package) |
| 313 else: |
| 314 desc_proto_prefix = '' |
| 315 |
| 316 for desc_proto in file_proto.message_type: |
| 317 desc = self._GetTypeFromScope(desc_proto_prefix, desc_proto.name, scope) |
| 318 file_descriptor.message_types_by_name[desc_proto.name] = desc |
| 319 self.Add(file_proto) |
| 320 self._file_descriptors[file_proto.name] = file_descriptor |
| 321 |
| 322 return self._file_descriptors[file_proto.name] |
| 323 |
| 324 def _ConvertMessageDescriptor(self, desc_proto, package=None, file_desc=None, |
| 325 scope=None): |
| 326 """Adds the proto to the pool in the specified package. |
| 327 |
| 328 Args: |
| 329 desc_proto: The descriptor_pb2.DescriptorProto protobuf message. |
| 330 package: The package the proto should be located in. |
| 331 file_desc: The file containing this message. |
| 332 scope: Dict mapping short and full symbols to message and enum types. |
| 333 |
| 334 Returns: |
| 335 The added descriptor. |
| 336 """ |
| 337 |
| 338 if package: |
| 339 desc_name = '.'.join((package, desc_proto.name)) |
| 340 else: |
| 341 desc_name = desc_proto.name |
| 342 |
| 343 if file_desc is None: |
| 344 file_name = None |
| 345 else: |
| 346 file_name = file_desc.name |
| 347 |
| 348 if scope is None: |
| 349 scope = {} |
| 350 |
| 351 nested = [ |
| 352 self._ConvertMessageDescriptor(nested, desc_name, file_desc, scope) |
| 353 for nested in desc_proto.nested_type] |
| 354 enums = [ |
| 355 self._ConvertEnumDescriptor(enum, desc_name, file_desc, None, scope) |
| 356 for enum in desc_proto.enum_type] |
| 357 fields = [self.MakeFieldDescriptor(field, desc_name, index) |
| 358 for index, field in enumerate(desc_proto.field)] |
| 359 extensions = [ |
| 360 self.MakeFieldDescriptor(extension, desc_name, index, is_extension=True) |
| 361 for index, extension in enumerate(desc_proto.extension)] |
| 362 oneofs = [ |
| 363 descriptor.OneofDescriptor(desc.name, '.'.join((desc_name, desc.name)), |
| 364 index, None, []) |
| 365 for index, desc in enumerate(desc_proto.oneof_decl)] |
| 366 extension_ranges = [(r.start, r.end) for r in desc_proto.extension_range] |
| 367 if extension_ranges: |
| 368 is_extendable = True |
| 369 else: |
| 370 is_extendable = False |
| 371 desc = descriptor.Descriptor( |
| 372 name=desc_proto.name, |
| 373 full_name=desc_name, |
| 374 filename=file_name, |
| 375 containing_type=None, |
| 376 fields=fields, |
| 377 oneofs=oneofs, |
| 378 nested_types=nested, |
| 379 enum_types=enums, |
| 380 extensions=extensions, |
| 381 options=desc_proto.options, |
| 382 is_extendable=is_extendable, |
| 383 extension_ranges=extension_ranges, |
| 384 file=file_desc, |
| 385 serialized_start=None, |
| 386 serialized_end=None) |
| 387 for nested in desc.nested_types: |
| 388 nested.containing_type = desc |
| 389 for enum in desc.enum_types: |
| 390 enum.containing_type = desc |
| 391 for field_index, field_desc in enumerate(desc_proto.field): |
| 392 if field_desc.HasField('oneof_index'): |
| 393 oneof_index = field_desc.oneof_index |
| 394 oneofs[oneof_index].fields.append(fields[field_index]) |
| 395 fields[field_index].containing_oneof = oneofs[oneof_index] |
| 396 |
| 397 scope[_PrefixWithDot(desc_name)] = desc |
| 398 self._descriptors[desc_name] = desc |
| 399 return desc |
| 400 |
| 401 def _ConvertEnumDescriptor(self, enum_proto, package=None, file_desc=None, |
| 402 containing_type=None, scope=None): |
| 403 """Make a protobuf EnumDescriptor given an EnumDescriptorProto protobuf. |
| 404 |
| 405 Args: |
| 406 enum_proto: The descriptor_pb2.EnumDescriptorProto protobuf message. |
| 407 package: Optional package name for the new message EnumDescriptor. |
| 408 file_desc: The file containing the enum descriptor. |
| 409 containing_type: The type containing this enum. |
| 410 scope: Scope containing available types. |
| 411 |
| 412 Returns: |
| 413 The added descriptor |
| 414 """ |
| 415 |
| 416 if package: |
| 417 enum_name = '.'.join((package, enum_proto.name)) |
| 418 else: |
| 419 enum_name = enum_proto.name |
| 420 |
| 421 if file_desc is None: |
| 422 file_name = None |
| 423 else: |
| 424 file_name = file_desc.name |
| 425 |
| 426 values = [self._MakeEnumValueDescriptor(value, index) |
| 427 for index, value in enumerate(enum_proto.value)] |
| 428 desc = descriptor.EnumDescriptor(name=enum_proto.name, |
| 429 full_name=enum_name, |
| 430 filename=file_name, |
| 431 file=file_desc, |
| 432 values=values, |
| 433 containing_type=containing_type, |
| 434 options=enum_proto.options) |
| 435 scope['.%s' % enum_name] = desc |
| 436 self._enum_descriptors[enum_name] = desc |
| 437 return desc |
| 438 |
| 439 def MakeFieldDescriptor(self, field_proto, message_name, index, |
| 440 is_extension=False): |
| 441 """Creates a field descriptor from a FieldDescriptorProto. |
| 442 |
| 443 For message and enum type fields, this method will do a look up |
| 444 in the pool for the appropriate descriptor for that type. If it |
| 445 is unavailable, it will fall back to the _source function to |
| 446 create it. If this type is still unavailable, construction will |
| 447 fail. |
| 448 |
| 449 Args: |
| 450 field_proto: The proto describing the field. |
| 451 message_name: The name of the containing message. |
| 452 index: Index of the field |
| 453 is_extension: Indication that this field is for an extension. |
| 454 |
| 455 Returns: |
| 456 An initialized FieldDescriptor object |
| 457 """ |
| 458 |
| 459 if message_name: |
| 460 full_name = '.'.join((message_name, field_proto.name)) |
| 461 else: |
| 462 full_name = field_proto.name |
| 463 |
| 464 return descriptor.FieldDescriptor( |
| 465 name=field_proto.name, |
| 466 full_name=full_name, |
| 467 index=index, |
| 468 number=field_proto.number, |
| 469 type=field_proto.type, |
| 470 cpp_type=None, |
| 471 message_type=None, |
| 472 enum_type=None, |
| 473 containing_type=None, |
| 474 label=field_proto.label, |
| 475 has_default_value=False, |
| 476 default_value=None, |
| 477 is_extension=is_extension, |
| 478 extension_scope=None, |
| 479 options=field_proto.options) |
| 480 |
| 481 def SetAllFieldTypes(self, package, desc_proto, scope): |
| 482 """Sets all the descriptor's fields's types. |
| 483 |
| 484 This method also sets the containing types on any extensions. |
| 485 |
| 486 Args: |
| 487 package: The current package of desc_proto. |
| 488 desc_proto: The message descriptor to update. |
| 489 scope: Enclosing scope of available types. |
| 490 """ |
| 491 |
| 492 package = _PrefixWithDot(package) |
| 493 |
| 494 main_desc = self._GetTypeFromScope(package, desc_proto.name, scope) |
| 495 |
| 496 if package == '.': |
| 497 nested_package = _PrefixWithDot(desc_proto.name) |
| 498 else: |
| 499 nested_package = '.'.join([package, desc_proto.name]) |
| 500 |
| 501 for field_proto, field_desc in zip(desc_proto.field, main_desc.fields): |
| 502 self.SetFieldType(field_proto, field_desc, nested_package, scope) |
| 503 |
| 504 for extension_proto, extension_desc in ( |
| 505 zip(desc_proto.extension, main_desc.extensions)): |
| 506 extension_desc.containing_type = self._GetTypeFromScope( |
| 507 nested_package, extension_proto.extendee, scope) |
| 508 self.SetFieldType(extension_proto, extension_desc, nested_package, scope) |
| 509 |
| 510 for nested_type in desc_proto.nested_type: |
| 511 self.SetAllFieldTypes(nested_package, nested_type, scope) |
| 512 |
| 513 def SetFieldType(self, field_proto, field_desc, package, scope): |
| 514 """Sets the field's type, cpp_type, message_type and enum_type. |
| 515 |
| 516 Args: |
| 517 field_proto: Data about the field in proto format. |
| 518 field_desc: The descriptor to modiy. |
| 519 package: The package the field's container is in. |
| 520 scope: Enclosing scope of available types. |
| 521 """ |
| 522 if field_proto.type_name: |
| 523 desc = self._GetTypeFromScope(package, field_proto.type_name, scope) |
| 524 else: |
| 525 desc = None |
| 526 |
| 527 if not field_proto.HasField('type'): |
| 528 if isinstance(desc, descriptor.Descriptor): |
| 529 field_proto.type = descriptor.FieldDescriptor.TYPE_MESSAGE |
| 530 else: |
| 531 field_proto.type = descriptor.FieldDescriptor.TYPE_ENUM |
| 532 |
| 533 field_desc.cpp_type = descriptor.FieldDescriptor.ProtoTypeToCppProtoType( |
| 534 field_proto.type) |
| 535 |
| 536 if (field_proto.type == descriptor.FieldDescriptor.TYPE_MESSAGE |
| 537 or field_proto.type == descriptor.FieldDescriptor.TYPE_GROUP): |
| 538 field_desc.message_type = desc |
| 539 |
| 540 if field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM: |
| 541 field_desc.enum_type = desc |
| 542 |
| 543 if field_proto.label == descriptor.FieldDescriptor.LABEL_REPEATED: |
| 544 field_desc.has_default_value = False |
| 545 field_desc.default_value = [] |
| 546 elif field_proto.HasField('default_value'): |
| 547 field_desc.has_default_value = True |
| 548 if (field_proto.type == descriptor.FieldDescriptor.TYPE_DOUBLE or |
| 549 field_proto.type == descriptor.FieldDescriptor.TYPE_FLOAT): |
| 550 field_desc.default_value = float(field_proto.default_value) |
| 551 elif field_proto.type == descriptor.FieldDescriptor.TYPE_STRING: |
| 552 field_desc.default_value = field_proto.default_value |
| 553 elif field_proto.type == descriptor.FieldDescriptor.TYPE_BOOL: |
| 554 field_desc.default_value = field_proto.default_value.lower() == 'true' |
| 555 elif field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM: |
| 556 field_desc.default_value = field_desc.enum_type.values_by_name[ |
| 557 field_proto.default_value].index |
| 558 elif field_proto.type == descriptor.FieldDescriptor.TYPE_BYTES: |
| 559 field_desc.default_value = text_encoding.CUnescape( |
| 560 field_proto.default_value) |
| 561 else: |
| 562 field_desc.default_value = int(field_proto.default_value) |
| 563 else: |
| 564 field_desc.has_default_value = False |
| 565 field_desc.default_value = None |
| 566 |
| 567 field_desc.type = field_proto.type |
| 568 |
| 569 def _MakeEnumValueDescriptor(self, value_proto, index): |
| 570 """Creates a enum value descriptor object from a enum value proto. |
| 571 |
| 572 Args: |
| 573 value_proto: The proto describing the enum value. |
| 574 index: The index of the enum value. |
| 575 |
| 576 Returns: |
| 577 An initialized EnumValueDescriptor object. |
| 578 """ |
| 579 |
| 580 return descriptor.EnumValueDescriptor( |
| 581 name=value_proto.name, |
| 582 index=index, |
| 583 number=value_proto.number, |
| 584 options=value_proto.options, |
| 585 type=None) |
| 586 |
| 587 def _ExtractSymbols(self, descriptors): |
| 588 """Pulls out all the symbols from descriptor protos. |
| 589 |
| 590 Args: |
| 591 descriptors: The messages to extract descriptors from. |
| 592 Yields: |
| 593 A two element tuple of the type name and descriptor object. |
| 594 """ |
| 595 |
| 596 for desc in descriptors: |
| 597 yield (_PrefixWithDot(desc.full_name), desc) |
| 598 for symbol in self._ExtractSymbols(desc.nested_types): |
| 599 yield symbol |
| 600 for enum in desc.enum_types: |
| 601 yield (_PrefixWithDot(enum.full_name), enum) |
| 602 |
| 603 def _GetDeps(self, dependencies): |
| 604 """Recursively finds dependencies for file protos. |
| 605 |
| 606 Args: |
| 607 dependencies: The names of the files being depended on. |
| 608 |
| 609 Yields: |
| 610 Each direct and indirect dependency. |
| 611 """ |
| 612 |
| 613 for dependency in dependencies: |
| 614 dep_desc = self.FindFileByName(dependency) |
| 615 yield dep_desc |
| 616 for parent_dep in dep_desc.dependencies: |
| 617 yield parent_dep |
| 618 |
| 619 def _GetTypeFromScope(self, package, type_name, scope): |
| 620 """Finds a given type name in the current scope. |
| 621 |
| 622 Args: |
| 623 package: The package the proto should be located in. |
| 624 type_name: The name of the type to be found in the scope. |
| 625 scope: Dict mapping short and full symbols to message and enum types. |
| 626 |
| 627 Returns: |
| 628 The descriptor for the requested type. |
| 629 """ |
| 630 if type_name not in scope: |
| 631 components = _PrefixWithDot(package).split('.') |
| 632 while components: |
| 633 possible_match = '.'.join(components + [type_name]) |
| 634 if possible_match in scope: |
| 635 type_name = possible_match |
| 636 break |
| 637 else: |
| 638 components.pop(-1) |
| 639 return scope[type_name] |
| 640 |
| 641 |
| 642 def _PrefixWithDot(name): |
| 643 return name if name.startswith('.') else '.%s' % name |
OLD | NEW |