protobuf 6.33.0__cp39-abi3-manylinux2014_s390x.whl

google/protobuf/proto.py

@@ -0,0 +1,153 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Contains the Nextgen Pythonic protobuf APIs."""
+
+import io
+from typing import Text, Type, TypeVar
+
+from google.protobuf.internal import decoder
+from google.protobuf.internal import encoder
+from google.protobuf.message import Message
+
+_MESSAGE = TypeVar('_MESSAGE', bound='Message')
+
+
+def serialize(message: _MESSAGE, deterministic: bool = None) -> bytes:
+  """Return the serialized proto.
+
+  Args:
+    message: The proto message to be serialized.
+    deterministic: If true, requests deterministic serialization
+        of the protobuf, with predictable ordering of map keys.
+
+  Returns:
+    A binary bytes representation of the message.
+  """
+  return message.SerializeToString(deterministic=deterministic)
+
+
+def parse(message_class: Type[_MESSAGE], payload: bytes) -> _MESSAGE:
+  """Given a serialized data in binary form, deserialize it into a Message.
+
+  Args:
+    message_class: The message meta class.
+    payload: A serialized bytes in binary form.
+
+  Returns:
+    A new message deserialized from payload.
+  """
+  new_message = message_class()
+  new_message.ParseFromString(payload)
+  return new_message
+
+
+def serialize_length_prefixed(message: _MESSAGE, output: io.BytesIO) -> None:
+  """Writes the size of the message as a varint and the serialized message.
+
+  Writes the size of the message as a varint and then the serialized message.
+  This allows more data to be written to the output after the message. Use
+  parse_length_prefixed to parse messages written by this method.
+
+  The output stream must be buffered, e.g. using
+  https://docs.python.org/3/library/io.html#buffered-streams.
+
+  Example usage:
+    out = io.BytesIO()
+    for msg in message_list:
+      proto.serialize_length_prefixed(msg, out)
+
+  Args:
+    message: The protocol buffer message that should be serialized.
+    output: BytesIO or custom buffered IO that data should be written to.
+  """
+  size = message.ByteSize()
+  encoder._VarintEncoder()(output.write, size)
+  out_size = output.write(serialize(message))
+
+  if out_size != size:
+    raise TypeError(
+        'Failed to write complete message (wrote: %d, expected: %d)'
+        '. Ensure output is using buffered IO.' % (out_size, size)
+    )
+
+
+def parse_length_prefixed(
+    message_class: Type[_MESSAGE], input_bytes: io.BytesIO
+) -> _MESSAGE:
+  """Parse a message from input_bytes.
+
+  Args:
+    message_class: The protocol buffer message class that parser should parse.
+    input_bytes: A buffered input.
+
+  Example usage:
+    while True:
+      msg = proto.parse_length_prefixed(message_class, input_bytes)
+      if msg is None:
+        break
+      ...
+
+  Returns:
+    A parsed message if successful. None if input_bytes is at EOF.
+  """
+  size = decoder._DecodeVarint(input_bytes)
+  if size is None:
+    # It is the end of buffered input. See example usage in the
+    # API description.
+    return None
+
+  message = message_class()
+
+  if size == 0:
+    return message
+
+  parsed_size = message.ParseFromString(input_bytes.read(size))
+  if parsed_size != size:
+    raise ValueError(
+        'Truncated message or non-buffered input_bytes: '
+        'Expected {0} bytes but only {1} bytes parsed for '
+        '{2}.'.format(size, parsed_size, message.DESCRIPTOR.name)
+    )
+  return message
+
+
+def byte_size(message: Message) -> int:
+  """Returns the serialized size of this message.
+
+  Args:
+    message: A proto message.
+
+  Returns:
+    int: The number of bytes required to serialize this message.
+  """
+  return message.ByteSize()
+
+
+def clear_message(message: Message) -> None:
+  """Clears all data that was set in the message.
+
+  Args:
+    message: The proto message to be cleared.
+  """
+  message.Clear()
+
+
+def clear_field(message: Message, field_name: Text) -> None:
+  """Clears the contents of a given field.
+
+  Inside a oneof group, clears the field set. If the name neither refers to a
+  defined field or oneof group, :exc:`ValueError` is raised.
+
+  Args:
+    message: The proto message.
+    field_name (str): The name of the field to be cleared.
+
+  Raises:
+    ValueError: if the `field_name` is not a member of this message.
+  """
+  message.ClearField(field_name)

google/protobuf/proto_builder.py

@@ -0,0 +1,111 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Dynamic Protobuf class creator."""
+
+from collections import OrderedDict
+import hashlib
+import os
+
+from google.protobuf import descriptor_pb2
+from google.protobuf import descriptor
+from google.protobuf import descriptor_pool
+from google.protobuf import message_factory
+
+
+def _GetMessageFromFactory(pool, full_name):
+  """Get a proto class from the MessageFactory by name.
+
+  Args:
+    pool: a descriptor pool.
+    full_name: str, the fully qualified name of the proto type.
+  Returns:
+    A class, for the type identified by full_name.
+  Raises:
+    KeyError, if the proto is not found in the factory's descriptor pool.
+  """
+  proto_descriptor = pool.FindMessageTypeByName(full_name)
+  proto_cls = message_factory.GetMessageClass(proto_descriptor)
+  return proto_cls
+
+
+def MakeSimpleProtoClass(fields, full_name=None, pool=None):
+  """Create a Protobuf class whose fields are basic types.
+
+  Note: this doesn't validate field names!
+
+  Args:
+    fields: dict of {name: field_type} mappings for each field in the proto. If
+        this is an OrderedDict the order will be maintained, otherwise the
+        fields will be sorted by name.
+    full_name: optional str, the fully-qualified name of the proto type.
+    pool: optional DescriptorPool instance.
+  Returns:
+    a class, the new protobuf class with a FileDescriptor.
+  """
+  pool_instance = pool or descriptor_pool.DescriptorPool()
+  if full_name is not None:
+    try:
+      proto_cls = _GetMessageFromFactory(pool_instance, full_name)
+      return proto_cls
+    except KeyError:
+      # The factory's DescriptorPool doesn't know about this class yet.
+      pass
+
+  # Get a list of (name, field_type) tuples from the fields dict. If fields was
+  # an OrderedDict we keep the order, but otherwise we sort the field to ensure
+  # consistent ordering.
+  field_items = fields.items()
+  if not isinstance(fields, OrderedDict):
+    field_items = sorted(field_items)
+
+  # Use a consistent file name that is unlikely to conflict with any imported
+  # proto files.
+  fields_hash = hashlib.sha1()
+  for f_name, f_type in field_items:
+    fields_hash.update(f_name.encode('utf-8'))
+    fields_hash.update(str(f_type).encode('utf-8'))
+  proto_file_name = fields_hash.hexdigest() + '.proto'
+
+  # If the proto is anonymous, use the same hash to name it.
+  if full_name is None:
+    full_name = ('net.proto2.python.public.proto_builder.AnonymousProto_' +
+                 fields_hash.hexdigest())
+    try:
+      proto_cls = _GetMessageFromFactory(pool_instance, full_name)
+      return proto_cls
+    except KeyError:
+      # The factory's DescriptorPool doesn't know about this class yet.
+      pass
+
+  # This is the first time we see this proto: add a new descriptor to the pool.
+  pool_instance.Add(
+      _MakeFileDescriptorProto(proto_file_name, full_name, field_items))
+  return _GetMessageFromFactory(pool_instance, full_name)
+
+
+def _MakeFileDescriptorProto(proto_file_name, full_name, field_items):
+  """Populate FileDescriptorProto for MessageFactory's DescriptorPool."""
+  package, name = full_name.rsplit('.', 1)
+  file_proto = descriptor_pb2.FileDescriptorProto()
+  file_proto.name = os.path.join(package.replace('.', '/'), proto_file_name)
+  file_proto.package = package
+  desc_proto = file_proto.message_type.add()
+  desc_proto.name = name
+  for f_number, (f_name, f_type) in enumerate(field_items, 1):
+    field_proto = desc_proto.field.add()
+    field_proto.name = f_name
+    # # If the number falls in the reserved range, reassign it to the correct
+    # # number after the range.
+    if f_number >= descriptor.FieldDescriptor.FIRST_RESERVED_FIELD_NUMBER:
+      f_number += (
+          descriptor.FieldDescriptor.LAST_RESERVED_FIELD_NUMBER -
+          descriptor.FieldDescriptor.FIRST_RESERVED_FIELD_NUMBER + 1)
+    field_proto.number = f_number
+    field_proto.label = descriptor_pb2.FieldDescriptorProto.LABEL_OPTIONAL
+    field_proto.type = f_type
+  return file_proto

google/protobuf/proto_json.py

@@ -0,0 +1,83 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Contains the Nextgen Pythonic Protobuf JSON APIs."""
+
+from typing import Optional, Type
+
+from google.protobuf.message import Message
+from google.protobuf.descriptor_pool import DescriptorPool
+from google.protobuf import json_format
+
+def serialize(
+    message: Message,
+    always_print_fields_with_no_presence: bool=False,
+    preserving_proto_field_name: bool=False,
+    use_integers_for_enums: bool=False,
+    descriptor_pool: Optional[DescriptorPool]=None,
+    float_precision: int=None,
+) -> dict:
+  """Converts protobuf message to a dictionary.
+
+  When the dictionary is encoded to JSON, it conforms to proto3 JSON spec.
+
+  Args:
+    message: The protocol buffers message instance to serialize.
+    always_print_fields_with_no_presence: If True, fields without
+      presence (implicit presence scalars, repeated fields, and map fields) will
+      always be serialized. Any field that supports presence is not affected by
+      this option (including singular message fields and oneof fields).
+    preserving_proto_field_name: If True, use the original proto field names as
+      defined in the .proto file. If False, convert the field names to
+      lowerCamelCase.
+    use_integers_for_enums: If true, print integers instead of enum names.
+    descriptor_pool: A Descriptor Pool for resolving types. If None use the
+      default.
+    float_precision: If set, use this to specify float field valid digits.
+
+  Returns:
+    A dict representation of the protocol buffer message.
+  """
+  return json_format.MessageToDict(
+      message,
+      always_print_fields_with_no_presence=always_print_fields_with_no_presence,
+      preserving_proto_field_name=preserving_proto_field_name,
+      use_integers_for_enums=use_integers_for_enums,
+      float_precision=float_precision,
+  )
+
+def parse(
+    message_class: Type[Message],
+    js_dict: dict,
+    ignore_unknown_fields: bool=False,
+    descriptor_pool: Optional[DescriptorPool]=None,
+    max_recursion_depth: int=100
+) -> Message:
+  """Parses a JSON dictionary representation into a message.
+
+  Args:
+    message_class: The message meta class.
+    js_dict: Dict representation of a JSON message.
+    ignore_unknown_fields: If True, do not raise errors for unknown fields.
+    descriptor_pool: A Descriptor Pool for resolving types. If None use the
+      default.
+    max_recursion_depth: max recursion depth of JSON message to be deserialized.
+      JSON messages over this depth will fail to be deserialized. Default value
+      is 100.
+
+  Returns:
+    A new message passed from json_dict.
+  """
+  new_message = message_class()
+  json_format.ParseDict(
+      js_dict=js_dict,
+      message=new_message,
+      ignore_unknown_fields=ignore_unknown_fields,
+      descriptor_pool=descriptor_pool,
+      max_recursion_depth=max_recursion_depth,
+  )
+  return new_message

google/protobuf/proto_text.py

@@ -0,0 +1,129 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2025 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Contains the Nextgen Pythonic Protobuf Text Format APIs."""
+from typing import AnyStr, Callable, Optional, Text, Type, Union
+
+from google.protobuf import text_format
+from google.protobuf.descriptor_pool import DescriptorPool
+from google.protobuf.message import Message
+
+_MsgFormatter = Callable[[Message, Union[int, bool], bool], Optional[Text]]
+
+
+def serialize(
+    message: Message,
+    as_utf8: bool = True,
+    as_one_line: bool = False,
+    use_short_repeated_primitives: bool = False,
+    pointy_brackets: bool = False,
+    use_index_order: bool = False,
+    float_format: Optional[str] = None,
+    double_format: Optional[str] = None,
+    use_field_number: bool = False,
+    descriptor_pool: Optional[DescriptorPool] = None,
+    indent: int = 0,
+    message_formatter: Optional[_MsgFormatter] = None,
+    print_unknown_fields: bool = False,
+    force_colon: bool = False,
+) -> str:
+  """Convert protobuf message to text format.
+
+  Double values can be formatted compactly with 15 digits of
+  precision (which is the most that IEEE 754 "double" can guarantee)
+  using double_format='.15g'. To ensure that converting to text and back to a
+  proto will result in an identical value, double_format='.17g' should be used.
+
+  Args:
+    message: The protocol buffers message.
+    as_utf8: Return unescaped Unicode for non-ASCII characters.
+    as_one_line: Don't introduce newlines between fields.
+    use_short_repeated_primitives: Use short repeated format for primitives.
+    pointy_brackets: If True, use angle brackets instead of curly braces for
+      nesting.
+    use_index_order: If True, fields of a proto message will be printed using
+      the order defined in source code instead of the field number, extensions
+      will be printed at the end of the message and their relative order is
+      determined by the extension number. By default, use the field number
+      order.
+    float_format (str): If set, use this to specify float field formatting (per
+      the "Format Specification Mini-Language"); otherwise, shortest float that
+      has same value in wire will be printed. Also affect double field if
+      double_format is not set but float_format is set.
+    double_format (str): If set, use this to specify double field formatting
+      (per the "Format Specification Mini-Language"); if it is not set but
+      float_format is set, use float_format. Otherwise, use ``str()``
+    use_field_number: If True, print field numbers instead of names.
+    descriptor_pool (DescriptorPool): Descriptor pool used to resolve Any types.
+    indent (int): The initial indent level, in terms of spaces, for pretty
+      print.
+    message_formatter (function(message, indent, as_one_line) -> unicode|None):
+      Custom formatter for selected sub-messages (usually based on message
+      type). Use to pretty print parts of the protobuf for easier diffing.
+    print_unknown_fields: If True, unknown fields will be printed.
+    force_colon: If set, a colon will be added after the field name even if the
+      field is a proto message.
+
+  Returns:
+    str: A string of the text formatted protocol buffer message.
+  """
+  return text_format.MessageToString(
+      message=message,
+      as_utf8=as_utf8,
+      as_one_line=as_one_line,
+      use_short_repeated_primitives=use_short_repeated_primitives,
+      pointy_brackets=pointy_brackets,
+      use_index_order=use_index_order,
+      float_format=float_format,
+      double_format=double_format,
+      use_field_number=use_field_number,
+      descriptor_pool=descriptor_pool,
+      indent=indent,
+      message_formatter=message_formatter,
+      print_unknown_fields=print_unknown_fields,
+      force_colon=force_colon,
+  )
+
+
+def parse(
+    message_class: Type[Message],
+    text: AnyStr,
+    allow_unknown_extension: bool = False,
+    allow_field_number: bool = False,
+    descriptor_pool: Optional[DescriptorPool] = None,
+    allow_unknown_field: bool = False,
+) -> Message:
+  """Parses a text representation of a protocol message into a message.
+
+  Args:
+    message_class: The message meta class.
+    text (str): Message text representation.
+    message (Message): A protocol buffer message to merge into.
+    allow_unknown_extension: if True, skip over missing extensions and keep
+      parsing
+    allow_field_number: if True, both field number and field name are allowed.
+    descriptor_pool (DescriptorPool): Descriptor pool used to resolve Any types.
+    allow_unknown_field: if True, skip over unknown field and keep parsing.
+      Avoid to use this option if possible. It may hide some errors (e.g.
+      spelling error on field name)
+
+  Returns:
+    Message: A new message passed from text.
+
+  Raises:
+    ParseError: On text parsing problems.
+  """
+  new_message = message_class()
+  text_format.Parse(
+      text=text,
+      message=new_message,
+      allow_unknown_extension=allow_unknown_extension,
+      allow_field_number=allow_field_number,
+      descriptor_pool=descriptor_pool,
+      allow_unknown_field=allow_unknown_field,
+  )
+  return new_message

google/protobuf/pyext/cpp_message.py

@@ -0,0 +1,49 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Protocol message implementation hooks for C++ implementation.
+
+Contains helper functions used to create protocol message classes from
+Descriptor objects at runtime backed by the protocol buffer C++ API.
+"""
+
+__author__ = 'tibell@google.com (Johan Tibell)'
+
+from google.protobuf.internal import api_implementation
+
+
+# pylint: disable=protected-access
+_message = api_implementation._c_module
+# TODO: Remove this import after fix api_implementation
+if _message is None:
+  from google.protobuf.pyext import _message
+
+
+class GeneratedProtocolMessageType(_message.MessageMeta):
+
+  """Metaclass for protocol message classes created at runtime from Descriptors.
+
+  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(.....)
+  factory = symbol_database.Default()
+  factory.pool.AddDescriptor(mydescriptor)
+  MyProtoClass = message_factory.GetMessageClass(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'

google/protobuf/reflection.py

@@ -0,0 +1,36 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+# 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)'
+
+import warnings
+
+from google.protobuf import message_factory
+from google.protobuf import symbol_database
+
+# The type of all Message classes.
+# Part of the public interface, but normally only used by message factories.
+GeneratedProtocolMessageType = message_factory._GENERATED_PROTOCOL_MESSAGE_TYPE
+
+MESSAGE_CLASS_CACHE = {}

google/protobuf/runtime_version.py

@@ -0,0 +1,104 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Protobuf Runtime versions and validators.
+
+It should only be accessed by Protobuf gencodes and tests. DO NOT USE it
+elsewhere.
+"""
+
+__author__ = 'shaod@google.com (Dennis Shao)'
+
+from enum import Enum
+import os
+import warnings
+
+
+class Domain(Enum):
+  GOOGLE_INTERNAL = 1
+  PUBLIC = 2
+
+
+# The versions of this Python Protobuf runtime to be changed automatically by
+# the Protobuf release process. Do not edit them manually.
+# These OSS versions are not stripped to avoid merging conflicts.
+OSS_DOMAIN = Domain.PUBLIC
+OSS_MAJOR = 6
+OSS_MINOR = 33
+OSS_PATCH = 0
+OSS_SUFFIX = ''
+
+DOMAIN = OSS_DOMAIN
+MAJOR = OSS_MAJOR
+MINOR = OSS_MINOR
+PATCH = OSS_PATCH
+SUFFIX = OSS_SUFFIX
+
+# Avoid flooding of warnings.
+_MAX_WARNING_COUNT = 20
+_warning_count = 0
+
+class VersionError(Exception):
+  """Exception class for version violation."""
+
+
+def _ReportVersionError(msg):
+  raise VersionError(msg)
+
+
+def ValidateProtobufRuntimeVersion(
+    gen_domain, gen_major, gen_minor, gen_patch, gen_suffix, location
+):
+  """Function to validate versions.
+
+  Args:
+    gen_domain: The domain where the code was generated from.
+    gen_major: The major version number of the gencode.
+    gen_minor: The minor version number of the gencode.
+    gen_patch: The patch version number of the gencode.
+    gen_suffix: The version suffix e.g. '-dev', '-rc1' of the gencode.
+    location: The proto location that causes the version violation.
+
+  Raises:
+    VersionError: if gencode version is invalid or incompatible with the
+    runtime.
+  """
+
+  disable_flag = os.getenv('TEMPORARILY_DISABLE_PROTOBUF_VERSION_CHECK')
+  if disable_flag is not None and disable_flag.lower() == 'true':
+    return
+
+  global _warning_count
+
+  version = f'{MAJOR}.{MINOR}.{PATCH}{SUFFIX}'
+  gen_version = f'{gen_major}.{gen_minor}.{gen_patch}{gen_suffix}'
+
+  if gen_major < 0 or gen_minor < 0 or gen_patch < 0:
+    raise VersionError(f'Invalid gencode version: {gen_version}')
+
+  error_prompt = (
+      'See Protobuf version guarantees at'
+      ' https://protobuf.dev/support/cross-version-runtime-guarantee.'
+  )
+
+  if gen_domain != DOMAIN:
+    _ReportVersionError(
+        'Detected mismatched Protobuf Gencode/Runtime domains when loading'
+        f' {location}: gencode {gen_domain.name} runtime {DOMAIN.name}.'
+        ' Cross-domain usage of Protobuf is not supported.'
+    )
+
+  if (
+      MAJOR < gen_major
+      or (MAJOR == gen_major and MINOR < gen_minor)
+      or (MAJOR == gen_major and MINOR == gen_minor and PATCH < gen_patch)
+  ):
+    _ReportVersionError(
+        'Detected incompatible Protobuf Gencode/Runtime versions when loading'
+        f' {location}: gencode {gen_version} runtime {version}. Runtime version'
+        f' cannot be older than the linked gencode version. {error_prompt}'
+    )