libv8 7.8.279.23.0beta1 → 8.4.255.0

data/vendor/depot_tools/third_party/protobuf26/message.py

@@ -1,284 +0,0 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2008 Google Inc.  All rights reserved.
-# http://code.google.com/p/protobuf/
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-# TODO(robinson): We should just make these methods all "pure-virtual" and move
-# all implementation out, into reflection.py for now.
-
-
-"""Contains an abstract base class for protocol messages."""
-
-__author__ = 'robinson@google.com (Will Robinson)'
-
-
-class Error(Exception): pass
-class DecodeError(Error): pass
-class EncodeError(Error): pass
-
-
-class Message(object):
-
-  """Abstract base class for protocol messages.
-
-  Protocol message classes are almost always generated by the protocol
-  compiler.  These generated types subclass Message and implement the methods
-  shown below.
-
-  TODO(robinson): Link to an HTML document here.
-
-  TODO(robinson): Document that instances of this class will also
-  have an Extensions attribute with __getitem__ and __setitem__.
-  Again, not sure how to best convey this.
-
-  TODO(robinson): Document that the class must also have a static
-    RegisterExtension(extension_field) method.
-    Not sure how to best express at this point.
-  """
-
-  # TODO(robinson): Document these fields and methods.
-
-  __slots__ = []
-
-  DESCRIPTOR = None
-
-  def __deepcopy__(self, memo=None):
-    clone = type(self)()
-    clone.MergeFrom(self)
-    return clone
-
-  def __eq__(self, other_msg):
-    """Recursively compares two messages by value and structure."""
-    raise NotImplementedError
-
-  def __ne__(self, other_msg):
-    # Can't just say self != other_msg, since that would infinitely recurse. :)
-    return not self == other_msg
-
-  def __hash__(self):
-    raise TypeError('unhashable object')
-
-  def __str__(self):
-    """Outputs a human-readable representation of the message."""
-    raise NotImplementedError
-
-  def __unicode__(self):
-    """Outputs a human-readable representation of the message."""
-    raise NotImplementedError
-
-  def MergeFrom(self, other_msg):
-    """Merges the contents of the specified message into current message.
-
-    This method merges the contents of the specified message into the current
-    message. Singular fields that are set in the specified message overwrite
-    the corresponding fields in the current message. Repeated fields are
-    appended. Singular sub-messages and groups are recursively merged.
-
-    Args:
-      other_msg: Message to merge into the current message.
-    """
-    raise NotImplementedError
-
-  def CopyFrom(self, other_msg):
-    """Copies the content of the specified message into the current message.
-
-    The method clears the current message and then merges the specified
-    message using MergeFrom.
-
-    Args:
-      other_msg: Message to copy into the current one.
-    """
-    if self is other_msg:
-      return
-    self.Clear()
-    self.MergeFrom(other_msg)
-
-  def Clear(self):
-    """Clears all data that was set in the message."""
-    raise NotImplementedError
-
-  def SetInParent(self):
-    """Mark this as present in the parent.
-
-    This normally happens automatically when you assign a field of a
-    sub-message, but sometimes you want to make the sub-message
-    present while keeping it empty.  If you find yourself using this,
-    you may want to reconsider your design."""
-    raise NotImplementedError
-
-  def IsInitialized(self):
-    """Checks if the message is initialized.
-
-    Returns:
-      The method returns True if the message is initialized (i.e. all of its
-      required fields are set).
-    """
-    raise NotImplementedError
-
-  # TODO(robinson): MergeFromString() should probably return None and be
-  # implemented in terms of a helper that returns the # of bytes read.  Our
-  # deserialization routines would use the helper when recursively
-  # deserializing, but the end user would almost always just want the no-return
-  # MergeFromString().
-
-  def MergeFromString(self, serialized):
-    """Merges serialized protocol buffer data into this message.
-
-    When we find a field in |serialized| that is already present
-    in this message:
-      - If it's a "repeated" field, we append to the end of our list.
-      - Else, if it's a scalar, we overwrite our field.
-      - Else, (it's a nonrepeated composite), we recursively merge
-        into the existing composite.
-
-    TODO(robinson): Document handling of unknown fields.
-
-    Args:
-      serialized: Any object that allows us to call buffer(serialized)
-        to access a string of bytes using the buffer interface.
-
-    TODO(robinson): When we switch to a helper, this will return None.
-
-    Returns:
-      The number of bytes read from |serialized|.
-      For non-group messages, this will always be len(serialized),
-      but for messages which are actually groups, this will
-      generally be less than len(serialized), since we must
-      stop when we reach an END_GROUP tag.  Note that if
-      we *do* stop because of an END_GROUP tag, the number
-      of bytes returned does not include the bytes
-      for the END_GROUP tag information.
-    """
-    raise NotImplementedError
-
-  def ParseFromString(self, serialized):
-    """Parse serialized protocol buffer data into this message.
-
-    Like MergeFromString(), except we clear the object first and
-    do not return the value that MergeFromString returns.
-    """
-    self.Clear()
-    self.MergeFromString(serialized)
-
-  def SerializeToString(self):
-    """Serializes the protocol message to a binary string.
-
-    Returns:
-      A binary string representation of the message if all of the required
-      fields in the message are set (i.e. the message is initialized).
-
-    Raises:
-      message.EncodeError if the message isn't initialized.
-    """
-    raise NotImplementedError
-
-  def SerializePartialToString(self):
-    """Serializes the protocol message to a binary string.
-
-    This method is similar to SerializeToString but doesn't check if the
-    message is initialized.
-
-    Returns:
-      A string representation of the partial message.
-    """
-    raise NotImplementedError
-
-  # TODO(robinson): Decide whether we like these better
-  # than auto-generated has_foo() and clear_foo() methods
-  # on the instances themselves.  This way is less consistent
-  # with C++, but it makes reflection-type access easier and
-  # reduces the number of magically autogenerated things.
-  #
-  # TODO(robinson): Be sure to document (and test) exactly
-  # which field names are accepted here.  Are we case-sensitive?
-  # What do we do with fields that share names with Python keywords
-  # like 'lambda' and 'yield'?
-  #
-  # nnorwitz says:
-  # """
-  # Typically (in python), an underscore is appended to names that are
-  # keywords. So they would become lambda_ or yield_.
-  # """
-  def ListFields(self):
-    """Returns a list of (FieldDescriptor, value) tuples for all
-    fields in the message which are not empty.  A singular field is non-empty
-    if HasField() would return true, and a repeated field is non-empty if
-    it contains at least one element.  The fields are ordered by field
-    number"""
-    raise NotImplementedError
-
-  def HasField(self, field_name):
-    """Checks if a certain field is set for the message. Note if the
-    field_name is not defined in the message descriptor, ValueError will be
-    raised."""
-    raise NotImplementedError
-
-  def ClearField(self, field_name):
-    raise NotImplementedError
-
-  def HasExtension(self, extension_handle):
-    raise NotImplementedError
-
-  def ClearExtension(self, extension_handle):
-    raise NotImplementedError
-
-  def ByteSize(self):
-    """Returns the serialized size of this message.
-    Recursively calls ByteSize() on all contained messages.
-    """
-    raise NotImplementedError
-
-  def _SetListener(self, message_listener):
-    """Internal method used by the protocol message implementation.
-    Clients should not call this directly.
-
-    Sets a listener that this message will call on certain state transitions.
-
-    The purpose of this method is to register back-edges from children to
-    parents at runtime, for the purpose of setting "has" bits and
-    byte-size-dirty bits in the parent and ancestor objects whenever a child or
-    descendant object is modified.
-
-    If the client wants to disconnect this Message from the object tree, she
-    explicitly sets callback to None.
-
-    If message_listener is None, unregisters any existing listener.  Otherwise,
-    message_listener must implement the MessageListener interface in
-    internal/message_listener.py, and we discard any listener registered
-    via a previous _SetListener() call.
-    """
-    raise NotImplementedError
-
-  def __getstate__(self):
-    """Support the pickle protocol."""
-    return dict(serialized=self.SerializePartialToString())
-
-  def __setstate__(self, state):
-    """Support the pickle protocol."""
-    self.__init__()
-    self.ParseFromString(state['serialized'])

data/vendor/depot_tools/third_party/protobuf26/message_factory.py

@@ -1,155 +0,0 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2008 Google Inc.  All rights reserved.
-# http://code.google.com/p/protobuf/
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#PY25 compatible for GAE.
-#
-# Copyright 2012 Google Inc. All Rights Reserved.
-
-"""Provides a factory class for generating dynamic messages.
-
-The easiest way to use this class is if you have access to the FileDescriptor
-protos containing the messages you want to create you can just do the following:
-
-message_classes = message_factory.GetMessages(iterable_of_file_descriptors)
-my_proto_instance = message_classes['some.proto.package.MessageName']()
-"""
-
-__author__ = 'matthewtoia@google.com (Matt Toia)'
-
-import sys  ##PY25
-from protobuf26 import descriptor_database
-from protobuf26 import descriptor_pool
-from protobuf26 import message
-from protobuf26 import reflection
-
-
-class MessageFactory(object):
-  """Factory for creating Proto2 messages from descriptors in a pool."""
-
-  def __init__(self, pool=None):
-    """Initializes a new factory."""
-    self.pool = (pool or descriptor_pool.DescriptorPool(
-        descriptor_database.DescriptorDatabase()))
-
-    # local cache of all classes built from protobuf descriptors
-    self._classes = {}
-
-  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.full_name not in self._classes:
-      descriptor_name = descriptor.name
-      if sys.version_info[0] < 3:  ##PY25
-##!PY25      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.full_name] = 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.full_name not in self._classes:
-          self.GetPrototype(extension.containing_type)
-        extended_class = self._classes[extension.containing_type.full_name]
-        extended_class.RegisterExtension(extension)
-    return self._classes[descriptor.full_name]
-
-  def GetMessages(self, files):
-    """Gets all the messages from a specified file.
-
-    This will find and resolve dependencies, failing if the descriptor
-    pool cannot satisfy them.
-
-    Args:
-      files: The file names to extract messages from.
-
-    Returns:
-      A dictionary mapping proto names to the message classes. This will include
-      any dependent messages as well as any messages defined in the same file as
-      a specified message.
-    """
-    result = {}
-    for file_name in files:
-      file_desc = self.pool.FindFileByName(file_name)
-      for name, msg in file_desc.message_types_by_name.iteritems():
-        if file_desc.package:
-          full_name = '.'.join([file_desc.package, name])
-        else:
-          full_name = msg.name
-        result[full_name] = self.GetPrototype(
-            self.pool.FindMessageTypeByName(full_name))
-
-      # While the extension FieldDescriptors are created by the descriptor pool,
-      # the python classes created in the factory need them to be registered
-      # explicitly, which is done below.
-      #
-      # The call to RegisterExtension will specifically check if the
-      # extension was already registered on the object and either
-      # ignore the registration if the original was the same, or raise
-      # an error if they were different.
-
-      for name, extension in file_desc.extensions_by_name.iteritems():
-        if extension.containing_type.full_name not in self._classes:
-          self.GetPrototype(extension.containing_type)
-        extended_class = self._classes[extension.containing_type.full_name]
-        extended_class.RegisterExtension(extension)
-    return result
-
-
-_FACTORY = MessageFactory()
-
-
-def GetMessages(file_protos):
-  """Builds a dictionary of all the messages available in a set of files.
-
-  Args:
-    file_protos: A sequence of file protos to build messages out of.
-
-  Returns:
-    A dictionary mapping proto names to the message classes. This will include
-    any dependent messages as well as any messages defined in the same file as
-    a specified message.
-  """
-  for file_proto in file_protos:
-    _FACTORY.pool.Add(file_proto)
-  return _FACTORY.GetMessages([file_proto.name for file_proto in file_protos])

data/vendor/depot_tools/third_party/protobuf26/reflection.py

@@ -1,205 +0,0 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2008 Google Inc.  All rights reserved.
-# http://code.google.com/p/protobuf/
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-# This code is meant to work on Python 2.4 and above only.
-
-"""Contains a metaclass and helper functions used to create
-protocol message classes from Descriptor objects at runtime.
-
-Recall that a metaclass is the "type" of a class.
-(A class is to a metaclass what an instance is to a class.)
-
-In this case, we use the GeneratedProtocolMessageType metaclass
-to inject all the useful functionality into the classes
-output by the protocol compiler at compile-time.
-
-The upshot of all this is that the real implementation
-details for ALL pure-Python protocol buffers are *here in
-this file*.
-"""
-
-__author__ = 'robinson@google.com (Will Robinson)'
-
-
-from protobuf26.internal import api_implementation
-from protobuf26 import descriptor as descriptor_mod
-from protobuf26 import message
-
-_FieldDescriptor = descriptor_mod.FieldDescriptor
-
-
-if api_implementation.Type() == 'cpp':
-  if api_implementation.Version() == 2:
-    from protobuf26.pyext import cpp_message
-    _NewMessage = cpp_message.NewMessage
-    _InitMessage = cpp_message.InitMessage
-  else:
-    from protobuf26.internal import cpp_message
-    _NewMessage = cpp_message.NewMessage
-    _InitMessage = cpp_message.InitMessage
-else:
-  from protobuf26.internal import python_message
-  _NewMessage = python_message.NewMessage
-  _InitMessage = python_message.InitMessage
-
-
-class GeneratedProtocolMessageType(type):
-
-  """Metaclass for protocol message classes created at runtime from Descriptors.
-
-  We add implementations for all methods described in the Message class.  We
-  also create properties to allow getting/setting all fields in the protocol
-  message.  Finally, we create slots to prevent users from accidentally
-  "setting" nonexistent fields in the protocol message, which then wouldn't get
-  serialized / deserialized properly.
-
-  The protocol compiler currently uses this metaclass to create protocol
-  message classes at runtime.  Clients can also manually create their own
-  classes at runtime, as in this example:
-
-  mydescriptor = Descriptor(.....)
-  class MyProtoClass(Message):
-    __metaclass__ = GeneratedProtocolMessageType
-    DESCRIPTOR = mydescriptor
-  myproto_instance = MyProtoClass()
-  myproto.foo_field = 23
-  ...
-
-  The above example will not work for nested types. If you wish to include them,
-  use reflection.MakeClass() instead of manually instantiating the class in
-  order to create the appropriate class structure.
-  """
-
-  # Must be consistent with the protocol-compiler code in
-  # proto2/compiler/internal/generator.*.
-  _DESCRIPTOR_KEY = 'DESCRIPTOR'
-
-  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]
-    bases = _NewMessage(bases, descriptor, dictionary)
-    superclass = super(GeneratedProtocolMessageType, cls)
-
-    new_class = superclass.__new__(cls, name, bases, dictionary)
-    setattr(descriptor, '_concrete_class', new_class)
-    return new_class
-
-  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)
-
-
-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
-
-
-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.
-  """
-  attributes = {}
-  for name, nested_type in descriptor.nested_types_by_name.items():
-    attributes[name] = MakeClass(nested_type)
-
-  attributes[GeneratedProtocolMessageType._DESCRIPTOR_KEY] = descriptor
-
-  return GeneratedProtocolMessageType(str(descriptor.name), (message.Message,),
-                                      attributes)