Python google.protobuf.message.Message() Examples
The following are 30 code examples for showing how to use google.protobuf.message.Message(). These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example.
You may check out the related API usage on the sidebar.
You may also want to check out all available functions/classes of the module
google.protobuf.message
, or try the search function
.
Example 1
Project: recipes-py Author: luci File: test_api.py License: Apache License 2.0 | 6 votes |
def environ(self, *proto_msgs, **kwargs): """Sets environment data for this test case.""" ret = self.test(None) to_apply = [] for msg in proto_msgs: if not isinstance(msg, PBMessage): raise ValueError( 'Positional arguments for api.properties must be protobuf messages.' ' Got: %r (type %r)' % (msg, type(msg))) to_apply.append(jsonpb.MessageToDict( msg, preserving_proto_field_name=True)) to_apply.append(kwargs) for dictionary in to_apply: for key, value in dictionary.iteritems(): if not isinstance(value, (int, float, basestring)): raise ValueError( 'Environment values must be int, float or string. ' 'Got: %r=%r (type %r)' % (key, value, type(value))) ret.environ[key] = str(value) return ret
Example 2
Project: recipes-py Author: luci File: recipe_api.py License: Apache License 2.0 | 6 votes |
def new_context(self, **section_pb_values): """Creates a new LUCI_CONTEXT file with the provided section values, all unmentioned sections in the current context will be copied over. The environment variable will NOT not be switched to the newly created context. Args: * section_pb_values (Dict[str, message.Message]) - A mapping of section_key to the new message value for that section. Returns the path (str) to the newly created LUCI_CONTEXT file. Returns None if section_pb_values is empty (i.e. No change to current context). """ section_values = { key: jsonpb.MessageToDict(pb_val) for key, pb_val in iteritems(section_pb_values) } with luci_context.stage(_leak=True, **section_values) as file_path: return file_path
Example 3
Project: lambda-packs Author: ryfeus File: reflection_test.py License: MIT License | 6 votes |
def testParsingFlatClassWithExplicitClassDeclaration(self): """Test that the generated class can parse a flat message.""" # TODO(xiaofeng): This test fails with cpp implemetnation in the call # of six.with_metaclass(). The other two callsites of with_metaclass # in this file are both excluded from cpp test, so it might be expected # to fail. Need someone more familiar with the python code to take a # look at this. if api_implementation.Type() != 'python': return file_descriptor = descriptor_pb2.FileDescriptorProto() file_descriptor.ParseFromString(self._GetSerializedFileDescriptor('A')) msg_descriptor = descriptor.MakeDescriptor( file_descriptor.message_type[0]) class MessageClass(six.with_metaclass(reflection.GeneratedProtocolMessageType, message.Message)): DESCRIPTOR = msg_descriptor msg = MessageClass() msg_str = ( 'flat: 0 ' 'flat: 1 ' 'flat: 2 ') text_format.Merge(msg_str, msg) self.assertEqual(msg.flat, [0, 1, 2])
Example 4
Project: lambda-packs Author: ryfeus File: python_message.py License: MIT License | 6 votes |
def _AddMessageMethods(message_descriptor, cls): """Adds implementations of all Message methods to cls.""" _AddListFieldsMethod(message_descriptor, cls) _AddHasFieldMethod(message_descriptor, cls) _AddClearFieldMethod(message_descriptor, cls) if message_descriptor.is_extendable: _AddClearExtensionMethod(cls) _AddHasExtensionMethod(cls) _AddEqualsMethod(message_descriptor, cls) _AddStrMethod(message_descriptor, cls) _AddReprMethod(message_descriptor, cls) _AddUnicodeMethod(message_descriptor, cls) _AddByteSizeMethod(message_descriptor, cls) _AddSerializeToStringMethod(message_descriptor, cls) _AddSerializePartialToStringMethod(message_descriptor, cls) _AddMergeFromStringMethod(message_descriptor, cls) _AddIsInitializedMethod(message_descriptor, cls) _AddMergeFromMethod(cls) _AddWhichOneofMethod(message_descriptor, cls) _AddReduceMethod(cls) # Adds methods which do not depend on cls. cls.Clear = _Clear cls.DiscardUnknownFields = _DiscardUnknownFields cls._SetListener = _SetListener
Example 5
Project: auto-alt-text-lambda-api Author: abhisuri97 File: reflection_test.py License: MIT License | 6 votes |
def testParsingFlatClassWithExplicitClassDeclaration(self): """Test that the generated class can parse a flat message.""" # TODO(xiaofeng): This test fails with cpp implemetnation in the call # of six.with_metaclass(). The other two callsites of with_metaclass # in this file are both excluded from cpp test, so it might be expected # to fail. Need someone more familiar with the python code to take a # look at this. if api_implementation.Type() != 'python': return file_descriptor = descriptor_pb2.FileDescriptorProto() file_descriptor.ParseFromString(self._GetSerializedFileDescriptor('A')) msg_descriptor = descriptor.MakeDescriptor( file_descriptor.message_type[0]) class MessageClass(six.with_metaclass(reflection.GeneratedProtocolMessageType, message.Message)): DESCRIPTOR = msg_descriptor msg = MessageClass() msg_str = ( 'flat: 0 ' 'flat: 1 ' 'flat: 2 ') text_format.Merge(msg_str, msg) self.assertEqual(msg.flat, [0, 1, 2])
Example 6
Project: auto-alt-text-lambda-api Author: abhisuri97 File: python_message.py License: MIT License | 6 votes |
def _AddMessageMethods(message_descriptor, cls): """Adds implementations of all Message methods to cls.""" _AddListFieldsMethod(message_descriptor, cls) _AddHasFieldMethod(message_descriptor, cls) _AddClearFieldMethod(message_descriptor, cls) if message_descriptor.is_extendable: _AddClearExtensionMethod(cls) _AddHasExtensionMethod(cls) _AddEqualsMethod(message_descriptor, cls) _AddStrMethod(message_descriptor, cls) _AddReprMethod(message_descriptor, cls) _AddUnicodeMethod(message_descriptor, cls) _AddByteSizeMethod(message_descriptor, cls) _AddSerializeToStringMethod(message_descriptor, cls) _AddSerializePartialToStringMethod(message_descriptor, cls) _AddMergeFromStringMethod(message_descriptor, cls) _AddIsInitializedMethod(message_descriptor, cls) _AddMergeFromMethod(cls) _AddWhichOneofMethod(message_descriptor, cls) # Adds methods which do not depend on cls. cls.Clear = _Clear cls.DiscardUnknownFields = _DiscardUnknownFields cls._SetListener = _SetListener
Example 7
Project: gax-python Author: googleapis File: protobuf.py License: BSD 3-Clause "New" or "Revised" License | 6 votes |
def setdefault(pb_or_dict, key, value): """Set the key on the object to the value if the current value is falsy. Because protobuf Messages do not distinguish between unset values and falsy ones particularly well, this method treats any falsy value (e.g. 0, empty list) as a target to be overwritten, on both Messages and dictionaries. Args: pb_or_dict (Union[~google.protobuf.message.Message, Mapping]): the object. key (str): The key on the object in question. value (Any): The value to set. Raises: TypeError: If pb_or_dict is not a Message or Mapping. """ if not get(pb_or_dict, key, default=None): set(pb_or_dict, key, value)
Example 8
Project: gax-python Author: googleapis File: messages.py License: BSD 3-Clause "New" or "Revised" License | 6 votes |
def get_messages(module): """Return a dictionary of message names and objects. Args: module (module): A Python module; dir() will be run against this module to find Message subclasses. Returns: dict[str, Message]: A dictionary with the Message class names as keys, and the Message subclasses themselves as values. """ answer = collections.OrderedDict() for name in dir(module): candidate = getattr(module, name) if inspect.isclass(candidate) and issubclass(candidate, Message): answer[name] = candidate return answer
Example 9
Project: sklearn-theano Author: sklearn-theano File: reflection_test.py License: BSD 3-Clause "New" or "Revised" License | 6 votes |
def testParsingFlatClassWithExplicitClassDeclaration(self): """Test that the generated class can parse a flat message.""" # TODO(xiaofeng): This test fails with cpp implemetnation in the call # of six.with_metaclass(). The other two callsites of with_metaclass # in this file are both excluded from cpp test, so it might be expected # to fail. Need someone more familiar with the python code to take a # look at this. if api_implementation.Type() != 'python': return file_descriptor = descriptor_pb2.FileDescriptorProto() file_descriptor.ParseFromString(self._GetSerializedFileDescriptor('A')) msg_descriptor = descriptor.MakeDescriptor( file_descriptor.message_type[0]) class MessageClass(six.with_metaclass(reflection.GeneratedProtocolMessageType, message.Message)): DESCRIPTOR = msg_descriptor msg = MessageClass() msg_str = ( 'flat: 0 ' 'flat: 1 ' 'flat: 2 ') text_format.Merge(msg_str, msg) self.assertEqual(msg.flat, [0, 1, 2])
Example 10
Project: sklearn-theano Author: sklearn-theano File: python_message.py License: BSD 3-Clause "New" or "Revised" License | 6 votes |
def _AddMessageMethods(message_descriptor, cls): """Adds implementations of all Message methods to cls.""" _AddListFieldsMethod(message_descriptor, cls) _AddHasFieldMethod(message_descriptor, cls) _AddClearFieldMethod(message_descriptor, cls) if message_descriptor.is_extendable: _AddClearExtensionMethod(cls) _AddHasExtensionMethod(cls) _AddClearMethod(message_descriptor, cls) _AddEqualsMethod(message_descriptor, cls) _AddStrMethod(message_descriptor, cls) _AddUnicodeMethod(message_descriptor, cls) _AddSetListenerMethod(cls) _AddByteSizeMethod(message_descriptor, cls) _AddSerializeToStringMethod(message_descriptor, cls) _AddSerializePartialToStringMethod(message_descriptor, cls) _AddMergeFromStringMethod(message_descriptor, cls) _AddIsInitializedMethod(message_descriptor, cls) _AddMergeFromMethod(cls) _AddWhichOneofMethod(message_descriptor, cls)
Example 11
Project: steam Author: ValvePython File: proto.py License: MIT License | 6 votes |
def proto_to_dict(message): """Converts protobuf message instance to dict :param message: protobuf message instance :return: parameters and their values :rtype: dict :raises: :class:`.TypeError` if ``message`` is not a proto message """ if not isinstance(message, _ProtoMessageType): raise TypeError("Expected `message` to be a instance of protobuf message") data = {} for desc, field in message.ListFields(): if desc.type == desc.TYPE_MESSAGE: if desc.label == desc.LABEL_REPEATED: data[desc.name] = list(map(proto_to_dict, field)) else: data[desc.name] = proto_to_dict(field) else: data[desc.name] = list(field) if desc.label == desc.LABEL_REPEATED else field return data
Example 12
Project: perceptron-benchmark Author: advboxes File: protobuf_to_dict.py License: Apache License 2.0 | 6 votes |
def dict_to_protobuf(pb_klass_or_instance, values, type_callable_map=REVERSE_TYPE_CALLABLE_MAP, \ strict=True): """Populates a protobuf model from a dictionary. :param pb_klass_or_instance: a protobuf message class, or an protobuf instance :type pb_klass_or_instance: a type or instance of a subclass of google.protobuf.message.Message :param dict values: a dictionary of values. Repeated and nested values are fully supported. :param dict type_callable_map: a mapping of protobuf types to callables for setting values on the target instance. :param bool strict: complain if keys in the map are not fields on the message. """ if isinstance(pb_klass_or_instance, Message): instance = pb_klass_or_instance else: instance = pb_klass_or_instance() return _dict_to_protobuf(instance, values, type_callable_map, strict)
Example 13
Project: botchallenge Author: katharosada File: reflection.py License: MIT License | 6 votes |
def __init__(cls, name, bases, dictionary): """Here we perform the majority of our work on the class. We add enum getters, an __init__ method, implementations of all Message methods, and properties for all fields in the protocol type. Args: name: Name of the class (ignored, but required by the metaclass protocol). 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] _InitMessage(descriptor, cls) superclass = super(GeneratedProtocolMessageType, cls) superclass.__init__(name, bases, dictionary)
Example 14
Project: botchallenge Author: katharosada File: reflection_test.py License: MIT License | 6 votes |
def testParsingFlatClassWithExplicitClassDeclaration(self): """Test that the generated class can parse a flat message.""" file_descriptor = descriptor_pb2.FileDescriptorProto() file_descriptor.ParseFromString(self._GetSerializedFileDescriptor('A')) msg_descriptor = descriptor.MakeDescriptor( file_descriptor.message_type[0]) class MessageClass(message.Message, metaclass=reflection.GeneratedProtocolMessageType): DESCRIPTOR = msg_descriptor msg = MessageClass() msg_str = ( 'flat: 0 ' 'flat: 1 ' 'flat: 2 ') text_format.Merge(msg_str, msg) self.assertEqual(msg.flat, [0, 1, 2])
Example 15
Project: recipes-py Author: luci File: test_api.py License: Apache License 2.0 | 5 votes |
def luci_context(self, **section_pb_values): """Sets the LUCI_CONTEXT for this test case. Args: * section_pb_values(Dict[str, message.Message]): A mapping of section_key to the proto value for that section. """ ret = self.test(None) for section_key, pb_val in iteritems(section_pb_values): if not isinstance(pb_val, message.Message): # pragma: no cover raise ValueError( 'Expected section value in LUCI_CONTEXT to be proto message;' 'Got: %r=%r (type %r)' % (section_key, pb_val, type(pb_val))) ret.luci_context[section_key] = jsonpb.MessageToDict(pb_val) return ret
Example 16
Project: recipes-py Author: luci File: test_api.py License: Apache License 2.0 | 5 votes |
def __call__(self, *proto_msgs, **kwargs): """Sets property data for this test case. You may pass a list of protobuf messages to use; their JSONPB representations will be merged together with `dict.update`. You may also pass explicit key/value pairs; these will be merged into properties at the top level with `dict.update`. """ ret = self.test(None) for msg in proto_msgs: if not isinstance(msg, PBMessage): raise ValueError( 'Positional arguments for api.properties must be protobuf messages.' ' Got: %r (type %r)' % (msg, type(msg))) ret.properties.update(**jsonpb.MessageToDict( msg, preserving_proto_field_name=True)) for key, value in kwargs.iteritems(): if isinstance(value, PBMessage): value = jsonpb.MessageToDict(value, preserving_proto_field_name=True) # TODO(iannucci): recursively validate type of value to be all JSONish # types. # TODO(iannucci): recursively convert Path instances to string here. ret.properties[key] = value return ret
Example 17
Project: recipes-py Author: luci File: test_api.py License: Apache License 2.0 | 5 votes |
def output(proto_msg, retcode=None, name=None): """Supplies placeholder data for a proto.output. Args: * proto_msg - Instance of a proto message that should be returned for this placeholder. * retcode (Optional[int]) - The returncode of the step. * name (Optional[str]) - The name of the placeholder you're mocking. """ if not isinstance(proto_msg, message.Message): # pragma: no cover raise ValueError("expected proto Message, got: %r" % (type(proto_msg),)) return proto_msg, retcode, name
Example 18
Project: recipes-py Author: luci File: api.py License: Apache License 2.0 | 5 votes |
def result(self, presentation, test): # This is a bit silly, but we only have the codec information here, and # we don't want the user to redundantly provide it in the test. if test.enabled and isinstance(test.data, message.Message): # We replace the test object with one containing raw bytes for raw_io. test = recipe_test_api.PlaceholderTestData( data=ProtoApi.encode(test.data, self._codec), name=self.name) # Save name before self.raw.result() deletes it. backing_file = self.backing_file raw_data = self.raw.result(presentation, test) if raw_data is None: if self.add_json_log in (True, 'on_failure'): presentation.logs[self.label + ' (read error)'] = [ 'Proto file was missing or unreadable:', ' ' + backing_file, ] return None valid = False invalid_error = '' ret = None try: ret = ProtoApi.decode( raw_data, self._msg_class, self._codec, **self._decoding_kwargs) valid = True except Exception as ex: # pragma: no cover invalid_error = str(ex) if self.add_json_log is True or ( self.add_json_log == 'on_failure' and presentation.status != 'SUCCESS'): if valid: jsonpb = ProtoApi.encode(ret, 'JSONPB', indent=2) presentation.logs[self.label] = jsonpb.splitlines() else: presentation.logs[self.label + ' (invalid)'] = raw_data.splitlines() presentation.logs[self.label + ' (exception)'] = ( invalid_error.splitlines()) return ret
Example 19
Project: recipes-py Author: luci File: api.py License: Apache License 2.0 | 5 votes |
def output(self, msg_class, codec, add_json_log=True, name=None, leak_to=None, **decoding_kwargs): """A placeholder which expands to a file path and then reads an encoded proto back from that location when the step finishes. Args: * msg_class (protobuf Message subclass) - The message type to decode. * codec ('BINARY'|'JSONPB'|'TEXTPB') - The encoder to use. * add_json_log (True|False|'on_failure') - Log a copy of the parsed proto in JSONPB form to a step link named `name`. If this is 'on_failure', only create this log when the step has a non-SUCCESS status. * leak_to (Optional[Path]) - This path will be used in place of a random temporary file, and the file will not be deleted at the end of the step. * decoding_kwargs - Passed directly to the chosen decoder. See: - BINARY: google.protobuf.message.Message.Parse - JSONPB: google.protobuf.json_format.Parse * 'ignore_unknown_fields' defaults to True. - TEXTPB: google.protobuf.text_format.Parse """ codec = proto_codec.resolve(codec) if not issubclass(msg_class, message.Message): # pragma: no cover raise ValueError('msg_class is unexpected type: %r' % (msg_class,)) if add_json_log not in (True, False, 'on_failure'): # pragma: no cover raise ValueError( 'unexpected value for add_json_log: %r' % (add_json_log,)) return ProtoOutputPlaceholder( self, msg_class, codec, add_json_log, name, leak_to, decoding_kwargs)
Example 20
Project: recipes-py Author: luci File: api.py License: Apache License 2.0 | 5 votes |
def encode(proto_msg, codec, **encoding_kwargs): """Encodes a proto message to a string. Args: * codec ('BINARY'|'JSONPB'|'TEXTPB') - The encoder to use. * encoding_kwargs - Passed directly to the chosen encoder. See output placeholder for details. Returns the encoded proto message. """ if not isinstance(proto_msg, message.Message): # pragma: no cover raise ValueError('proto_msg had unexpected type: %s' % (type(proto_msg),)) return proto_codec.do_enc(codec, proto_msg, **encoding_kwargs)
Example 21
Project: recipes-py Author: luci File: api.py License: Apache License 2.0 | 5 votes |
def decode(data, msg_class, codec, **decoding_kwargs): """Decodes a proto message from a string. Args: * msg_class (protobuf Message subclass) - The message type to decode. * codec ('BINARY'|'JSONPB'|'TEXTPB') - The encoder to use. * decoding_kwargs - Passed directly to the chosen decoder. See input placeholder for details. Returns the decoded proto object. """ if not issubclass(msg_class, message.Message): # pragma: no cover raise ValueError('msg_class is unexpected type: %r' % (msg_class,)) return proto_codec.do_dec(data, msg_class, codec, **decoding_kwargs)
Example 22
Project: sawtooth-core Author: hyperledger File: rest_client.py License: Apache License 2.0 | 5 votes |
def send_batches(self, batch_list): """Sends a list of batches to the validator. Args: batch_list (:obj:`BatchList`): the list of batches Returns: dict: the json result data, as a dict """ if isinstance(batch_list, BaseMessage): batch_list = batch_list.SerializeToString() return self._post('/batches', batch_list)
Example 23
Project: lambda-packs Author: ryfeus File: reflection.py License: MIT License | 5 votes |
def ParseMessage(descriptor, byte_str): """Generate a new Message instance from this Descriptor and a byte string. Args: descriptor: Protobuf Descriptor object byte_str: Serialized protocol buffer byte string Returns: Newly created protobuf Message object. """ result_class = MakeClass(descriptor) new_msg = result_class() new_msg.ParseFromString(byte_str) return new_msg
Example 24
Project: lambda-packs Author: ryfeus File: reflection.py License: MIT License | 5 votes |
def MakeClass(descriptor): """Construct a class object for a protobuf described by descriptor. Composite descriptors are handled by defining the new class as a member of the parent class, recursing as deep as necessary. This is the dynamic equivalent to: class Parent(message.Message): __metaclass__ = GeneratedProtocolMessageType DESCRIPTOR = descriptor class Child(message.Message): __metaclass__ = GeneratedProtocolMessageType DESCRIPTOR = descriptor.nested_types[0] Sample usage: file_descriptor = descriptor_pb2.FileDescriptorProto() file_descriptor.ParseFromString(proto2_string) msg_descriptor = descriptor.MakeDescriptor(file_descriptor.message_type[0]) msg_class = reflection.MakeClass(msg_descriptor) msg = msg_class() Args: descriptor: A descriptor.Descriptor object describing the protobuf. Returns: The Message class object described by the descriptor. """ if descriptor in MESSAGE_CLASS_CACHE: return MESSAGE_CLASS_CACHE[descriptor] attributes = {} for name, nested_type in list(descriptor.nested_types_by_name.items()): attributes[name] = MakeClass(nested_type) attributes[GeneratedProtocolMessageType._DESCRIPTOR_KEY] = descriptor result = GeneratedProtocolMessageType( str(descriptor.name), (message.Message,), attributes) MESSAGE_CLASS_CACHE[descriptor] = result return result
Example 25
Project: lambda-packs Author: ryfeus File: message_factory.py License: MIT License | 5 votes |
def GetPrototype(self, descriptor): """Builds a proto2 message class based on the passed in descriptor. Passing a descriptor with a fully qualified name matching a previous invocation will cause the same class to be returned. Args: descriptor: The descriptor to build from. Returns: A class describing the passed in descriptor. """ if descriptor not in self._classes: descriptor_name = descriptor.name if str is bytes: # PY2 descriptor_name = descriptor.name.encode('ascii', 'ignore') result_class = reflection.GeneratedProtocolMessageType( descriptor_name, (message.Message,), {'DESCRIPTOR': descriptor, '__module__': None}) # If module not set, it wrongly points to the reflection.py module. self._classes[descriptor] = result_class for field in descriptor.fields: if field.message_type: self.GetPrototype(field.message_type) for extension in result_class.DESCRIPTOR.extensions: if extension.containing_type not in self._classes: self.GetPrototype(extension.containing_type) extended_class = self._classes[extension.containing_type] extended_class.RegisterExtension(extension) return self._classes[descriptor]
Example 26
Project: lambda-packs Author: ryfeus File: reflection_test.py License: MIT License | 5 votes |
def testHandWrittenReflection(self): # Hand written extensions are only supported by the pure-Python # implementation of the API. if api_implementation.Type() != 'python': return FieldDescriptor = descriptor.FieldDescriptor foo_field_descriptor = FieldDescriptor( name='foo_field', full_name='MyProto.foo_field', index=0, number=1, type=FieldDescriptor.TYPE_INT64, cpp_type=FieldDescriptor.CPPTYPE_INT64, label=FieldDescriptor.LABEL_OPTIONAL, default_value=0, containing_type=None, message_type=None, enum_type=None, is_extension=False, extension_scope=None, options=descriptor_pb2.FieldOptions()) mydescriptor = descriptor.Descriptor( name='MyProto', full_name='MyProto', filename='ignored', containing_type=None, nested_types=[], enum_types=[], fields=[foo_field_descriptor], extensions=[], options=descriptor_pb2.MessageOptions()) class MyProtoClass(six.with_metaclass(reflection.GeneratedProtocolMessageType, message.Message)): DESCRIPTOR = mydescriptor myproto_instance = MyProtoClass() self.assertEqual(0, myproto_instance.foo_field) self.assertTrue(not myproto_instance.HasField('foo_field')) myproto_instance.foo_field = 23 self.assertEqual(23, myproto_instance.foo_field) self.assertTrue(myproto_instance.HasField('foo_field'))
Example 27
Project: lambda-packs Author: ryfeus File: reflection_test.py License: MIT License | 5 votes |
def testSerializeUninitializedSubMessage(self): proto = unittest_pb2.TestRequiredForeign() # Sub-message doesn't exist yet, so this succeeds. proto.SerializeToString() proto.optional_message.a = 1 self._CheckRaises( message.EncodeError, proto.SerializeToString, 'Message protobuf_unittest.TestRequiredForeign ' 'is missing required fields: ' 'optional_message.b,optional_message.c') proto.optional_message.b = 2 proto.optional_message.c = 3 proto.SerializeToString() proto.repeated_message.add().a = 1 proto.repeated_message.add().b = 2 self._CheckRaises( message.EncodeError, proto.SerializeToString, 'Message protobuf_unittest.TestRequiredForeign is missing required fields: ' 'repeated_message[0].b,repeated_message[0].c,' 'repeated_message[1].a,repeated_message[1].c') proto.repeated_message[0].b = 2 proto.repeated_message[0].c = 3 proto.repeated_message[1].a = 1 proto.repeated_message[1].c = 3 proto.SerializeToString()
Example 28
Project: lambda-packs Author: ryfeus File: python_message.py License: MIT License | 5 votes |
def __new__(cls, name, bases, dictionary): """Custom allocation for runtime-generated class types. We override __new__ because this is apparently the only place where we can meaningfully set __slots__ on the class we're creating(?). (The interplay between metaclasses and slots is not very well-documented). Args: name: Name of the class (ignored, but required by the metaclass protocol). 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. Returns: Newly-allocated class. """ descriptor = dictionary[GeneratedProtocolMessageType._DESCRIPTOR_KEY] if descriptor.full_name in well_known_types.WKTBASES: bases += (well_known_types.WKTBASES[descriptor.full_name],) _AddClassAttributesForNestedExtensions(descriptor, dictionary) _AddSlots(descriptor, dictionary) superclass = super(GeneratedProtocolMessageType, cls) new_class = superclass.__new__(cls, name, bases, dictionary) return new_class
Example 29
Project: lambda-packs Author: ryfeus File: python_message.py License: MIT License | 5 votes |
def _AddSerializeToStringMethod(message_descriptor, cls): """Helper for _AddMessageMethods().""" def SerializeToString(self, **kwargs): # Check if the message has all of its required fields set. errors = [] if not self.IsInitialized(): raise message_mod.EncodeError( 'Message %s is missing required fields: %s' % ( self.DESCRIPTOR.full_name, ','.join(self.FindInitializationErrors()))) return self.SerializePartialToString(**kwargs) cls.SerializeToString = SerializeToString
Example 30
Project: lambda-packs Author: ryfeus File: python_message.py License: MIT License | 5 votes |
def __init__(self, extended_message): """extended_message: Message instance for which we are the Extensions dict. """ self._extended_message = extended_message