@uns-kit/cli 0.0.51 → 0.0.53

package/templates/python/venv/lib/python3.12/site-packages/google/protobuf/service_reflection.py

@@ -1,272 +0,0 @@
-# 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 metaclasses used to create protocol service and service stub
-classes from ServiceDescriptor objects at runtime.
-
-The GeneratedServiceType and GeneratedServiceStubType metaclasses are used to
-inject all useful functionality into the classes output by the protocol
-compiler at compile-time.
-"""
-
-__author__ = 'petar@google.com (Petar Petrov)'
-
-
-class GeneratedServiceType(type):
-
-  """Metaclass for service classes created at runtime from ServiceDescriptors.
-
-  Implementations for all methods described in the Service class are added here
-  by this class. We also create properties to allow getting/setting all fields
-  in the protocol message.
-
-  The protocol compiler currently uses this metaclass to create protocol service
-  classes at runtime. Clients can also manually create their own classes at
-  runtime, as in this example::
-
-    mydescriptor = ServiceDescriptor(.....)
-    class MyProtoService(service.Service):
-      __metaclass__ = GeneratedServiceType
-      DESCRIPTOR = mydescriptor
-    myservice_instance = MyProtoService()
-    # ...
-  """
-
-  _DESCRIPTOR_KEY = 'DESCRIPTOR'
-
-  def __init__(cls, name, bases, dictionary):
-    """Creates a message service class.
-
-    Args:
-      name: Name of the class (ignored, but required by the metaclass
-        protocol).
-      bases: Base classes of the class being constructed.
-      dictionary: The class dictionary of the class being constructed.
-        dictionary[_DESCRIPTOR_KEY] must contain a ServiceDescriptor object
-        describing this protocol service type.
-    """
-    # Don't do anything if this class doesn't have a descriptor. This happens
-    # when a service class is subclassed.
-    if GeneratedServiceType._DESCRIPTOR_KEY not in dictionary:
-      return
-
-    descriptor = dictionary[GeneratedServiceType._DESCRIPTOR_KEY]
-    service_builder = _ServiceBuilder(descriptor)
-    service_builder.BuildService(cls)
-    cls.DESCRIPTOR = descriptor
-
-
-class GeneratedServiceStubType(GeneratedServiceType):
-
-  """Metaclass for service stubs created at runtime from ServiceDescriptors.
-
-  This class has similar responsibilities as GeneratedServiceType, except that
-  it creates the service stub classes.
-  """
-
-  _DESCRIPTOR_KEY = 'DESCRIPTOR'
-
-  def __init__(cls, name, bases, dictionary):
-    """Creates a message service stub class.
-
-    Args:
-      name: Name of the class (ignored, here).
-      bases: Base classes of the class being constructed.
-      dictionary: The class dictionary of the class being constructed.
-        dictionary[_DESCRIPTOR_KEY] must contain a ServiceDescriptor object
-        describing this protocol service type.
-    """
-    super(GeneratedServiceStubType, cls).__init__(name, bases, dictionary)
-    # Don't do anything if this class doesn't have a descriptor. This happens
-    # when a service stub is subclassed.
-    if GeneratedServiceStubType._DESCRIPTOR_KEY not in dictionary:
-      return
-
-    descriptor = dictionary[GeneratedServiceStubType._DESCRIPTOR_KEY]
-    service_stub_builder = _ServiceStubBuilder(descriptor)
-    service_stub_builder.BuildServiceStub(cls)
-
-
-class _ServiceBuilder(object):
-
-  """This class constructs a protocol service class using a service descriptor.
-
-  Given a service descriptor, this class constructs a class that represents
-  the specified service descriptor. One service builder instance constructs
-  exactly one service class. That means all instances of that class share the
-  same builder.
-  """
-
-  def __init__(self, service_descriptor):
-    """Initializes an instance of the service class builder.
-
-    Args:
-      service_descriptor: ServiceDescriptor to use when constructing the
-        service class.
-    """
-    self.descriptor = service_descriptor
-
-  def BuildService(builder, cls):
-    """Constructs the service class.
-
-    Args:
-      cls: The class that will be constructed.
-    """
-
-    # CallMethod needs to operate with an instance of the Service class. This
-    # internal wrapper function exists only to be able to pass the service
-    # instance to the method that does the real CallMethod work.
-    # Making sure to use exact argument names from the abstract interface in
-    # service.py to match the type signature
-    def _WrapCallMethod(self, method_descriptor, rpc_controller, request, done):
-      return builder._CallMethod(self, method_descriptor, rpc_controller,
-                                 request, done)
-
-    def _WrapGetRequestClass(self, method_descriptor):
-      return builder._GetRequestClass(method_descriptor)
-
-    def _WrapGetResponseClass(self, method_descriptor):
-      return builder._GetResponseClass(method_descriptor)
-
-    builder.cls = cls
-    cls.CallMethod = _WrapCallMethod
-    cls.GetDescriptor = staticmethod(lambda: builder.descriptor)
-    cls.GetDescriptor.__doc__ = 'Returns the service descriptor.'
-    cls.GetRequestClass = _WrapGetRequestClass
-    cls.GetResponseClass = _WrapGetResponseClass
-    for method in builder.descriptor.methods:
-      setattr(cls, method.name, builder._GenerateNonImplementedMethod(method))
-
-  def _CallMethod(self, srvc, method_descriptor,
-                  rpc_controller, request, callback):
-    """Calls the method described by a given method descriptor.
-
-    Args:
-      srvc: Instance of the service for which this method is called.
-      method_descriptor: Descriptor that represent the method to call.
-      rpc_controller: RPC controller to use for this method's execution.
-      request: Request protocol message.
-      callback: A callback to invoke after the method has completed.
-    """
-    if method_descriptor.containing_service != self.descriptor:
-      raise RuntimeError(
-          'CallMethod() given method descriptor for wrong service type.')
-    method = getattr(srvc, method_descriptor.name)
-    return method(rpc_controller, request, callback)
-
-  def _GetRequestClass(self, method_descriptor):
-    """Returns the class of the request protocol message.
-
-    Args:
-      method_descriptor: Descriptor of the method for which to return the
-        request protocol message class.
-
-    Returns:
-      A class that represents the input protocol message of the specified
-      method.
-    """
-    if method_descriptor.containing_service != self.descriptor:
-      raise RuntimeError(
-          'GetRequestClass() given method descriptor for wrong service type.')
-    return method_descriptor.input_type._concrete_class
-
-  def _GetResponseClass(self, method_descriptor):
-    """Returns the class of the response protocol message.
-
-    Args:
-      method_descriptor: Descriptor of the method for which to return the
-        response protocol message class.
-
-    Returns:
-      A class that represents the output protocol message of the specified
-      method.
-    """
-    if method_descriptor.containing_service != self.descriptor:
-      raise RuntimeError(
-          'GetResponseClass() given method descriptor for wrong service type.')
-    return method_descriptor.output_type._concrete_class
-
-  def _GenerateNonImplementedMethod(self, method):
-    """Generates and returns a method that can be set for a service methods.
-
-    Args:
-      method: Descriptor of the service method for which a method is to be
-        generated.
-
-    Returns:
-      A method that can be added to the service class.
-    """
-    return lambda inst, rpc_controller, request, callback: (
-        self._NonImplementedMethod(method.name, rpc_controller, callback))
-
-  def _NonImplementedMethod(self, method_name, rpc_controller, callback):
-    """The body of all methods in the generated service class.
-
-    Args:
-      method_name: Name of the method being executed.
-      rpc_controller: RPC controller used to execute this method.
-      callback: A callback which will be invoked when the method finishes.
-    """
-    rpc_controller.SetFailed('Method %s not implemented.' % method_name)
-    callback(None)
-
-
-class _ServiceStubBuilder(object):
-
-  """Constructs a protocol service stub class using a service descriptor.
-
-  Given a service descriptor, this class constructs a suitable stub class.
-  A stub is just a type-safe wrapper around an RpcChannel which emulates a
-  local implementation of the service.
-
-  One service stub builder instance constructs exactly one class. It means all
-  instances of that class share the same service stub builder.
-  """
-
-  def __init__(self, service_descriptor):
-    """Initializes an instance of the service stub class builder.
-
-    Args:
-      service_descriptor: ServiceDescriptor to use when constructing the
-        stub class.
-    """
-    self.descriptor = service_descriptor
-
-  def BuildServiceStub(self, cls):
-    """Constructs the stub class.
-
-    Args:
-      cls: The class that will be constructed.
-    """
-
-    def _ServiceStubInit(stub, rpc_channel):
-      stub.rpc_channel = rpc_channel
-    self.cls = cls
-    cls.__init__ = _ServiceStubInit
-    for method in self.descriptor.methods:
-      setattr(cls, method.name, self._GenerateStubMethod(method))
-
-  def _GenerateStubMethod(self, method):
-    return (lambda inst, rpc_controller, request, callback=None:
-        self._StubMethod(inst, method, rpc_controller, request, callback))
-
-  def _StubMethod(self, stub, method_descriptor,
-                  rpc_controller, request, callback):
-    """The body of all service methods in the generated stub class.
-
-    Args:
-      stub: Stub instance.
-      method_descriptor: Descriptor of the invoked method.
-      rpc_controller: Rpc controller to execute the method.
-      request: Request protocol message.
-      callback: A callback to execute when the method finishes.
-    Returns:
-      Response message (in case of blocking call).
-    """
-    return stub.rpc_channel.CallMethod(
-        method_descriptor, rpc_controller, request,
-        method_descriptor.output_type._concrete_class, callback)

package/templates/python/venv/lib/python3.12/site-packages/google/protobuf/source_context_pb2.py

@@ -1,37 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# NO CHECKED-IN PROTOBUF GENCODE
-# source: google/protobuf/source_context.proto
-# Protobuf Python Version: 6.31.1
-"""Generated protocol buffer code."""
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import descriptor_pool as _descriptor_pool
-from google.protobuf import runtime_version as _runtime_version
-from google.protobuf import symbol_database as _symbol_database
-from google.protobuf.internal import builder as _builder
-_runtime_version.ValidateProtobufRuntimeVersion(
-    _runtime_version.Domain.PUBLIC,
-    6,
-    31,
-    1,
-    '',
-    'google/protobuf/source_context.proto'
-)
-# @@protoc_insertion_point(imports)
-
-_sym_db = _symbol_database.Default()
-
-
-
-
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$google/protobuf/source_context.proto\x12\x0fgoogle.protobuf\",\n\rSourceContext\x12\x1b\n\tfile_name\x18\x01 \x01(\tR\x08\x66ileNameB\x8a\x01\n\x13\x63om.google.protobufB\x12SourceContextProtoP\x01Z6google.golang.org/protobuf/types/known/sourcecontextpb\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
-
-_globals = globals()
-_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
-_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.source_context_pb2', _globals)
-if not _descriptor._USE_C_DESCRIPTORS:
-  _globals['DESCRIPTOR']._loaded_options = None
-  _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\022SourceContextProtoP\001Z6google.golang.org/protobuf/types/known/sourcecontextpb\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
-  _globals['_SOURCECONTEXT']._serialized_start=57
-  _globals['_SOURCECONTEXT']._serialized_end=101
-# @@protoc_insertion_point(module_scope)

package/templates/python/venv/lib/python3.12/site-packages/google/protobuf/struct_pb2.py

@@ -1,47 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# NO CHECKED-IN PROTOBUF GENCODE
-# source: google/protobuf/struct.proto
-# Protobuf Python Version: 6.31.1
-"""Generated protocol buffer code."""
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import descriptor_pool as _descriptor_pool
-from google.protobuf import runtime_version as _runtime_version
-from google.protobuf import symbol_database as _symbol_database
-from google.protobuf.internal import builder as _builder
-_runtime_version.ValidateProtobufRuntimeVersion(
-    _runtime_version.Domain.PUBLIC,
-    6,
-    31,
-    1,
-    '',
-    'google/protobuf/struct.proto'
-)
-# @@protoc_insertion_point(imports)
-
-_sym_db = _symbol_database.Default()
-
-
-
-
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1cgoogle/protobuf/struct.proto\x12\x0fgoogle.protobuf\"\x98\x01\n\x06Struct\x12;\n\x06\x66ields\x18\x01 \x03(\x0b\x32#.google.protobuf.Struct.FieldsEntryR\x06\x66ields\x1aQ\n\x0b\x46ieldsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.ValueR\x05value:\x02\x38\x01\"\xb2\x02\n\x05Value\x12;\n\nnull_value\x18\x01 \x01(\x0e\x32\x1a.google.protobuf.NullValueH\x00R\tnullValue\x12#\n\x0cnumber_value\x18\x02 \x01(\x01H\x00R\x0bnumberValue\x12#\n\x0cstring_value\x18\x03 \x01(\tH\x00R\x0bstringValue\x12\x1f\n\nbool_value\x18\x04 \x01(\x08H\x00R\tboolValue\x12<\n\x0cstruct_value\x18\x05 \x01(\x0b\x32\x17.google.protobuf.StructH\x00R\x0bstructValue\x12;\n\nlist_value\x18\x06 \x01(\x0b\x32\x1a.google.protobuf.ListValueH\x00R\tlistValueB\x06\n\x04kind\";\n\tListValue\x12.\n\x06values\x18\x01 \x03(\x0b\x32\x16.google.protobuf.ValueR\x06values*\x1b\n\tNullValue\x12\x0e\n\nNULL_VALUE\x10\x00\x42\x7f\n\x13\x63om.google.protobufB\x0bStructProtoP\x01Z/google.golang.org/protobuf/types/known/structpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
-
-_globals = globals()
-_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
-_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.struct_pb2', _globals)
-if not _descriptor._USE_C_DESCRIPTORS:
-  _globals['DESCRIPTOR']._loaded_options = None
-  _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\013StructProtoP\001Z/google.golang.org/protobuf/types/known/structpb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
-  _globals['_STRUCT_FIELDSENTRY']._loaded_options = None
-  _globals['_STRUCT_FIELDSENTRY']._serialized_options = b'8\001'
-  _globals['_NULLVALUE']._serialized_start=574
-  _globals['_NULLVALUE']._serialized_end=601
-  _globals['_STRUCT']._serialized_start=50
-  _globals['_STRUCT']._serialized_end=202
-  _globals['_STRUCT_FIELDSENTRY']._serialized_start=121
-  _globals['_STRUCT_FIELDSENTRY']._serialized_end=202
-  _globals['_VALUE']._serialized_start=205
-  _globals['_VALUE']._serialized_end=511
-  _globals['_LISTVALUE']._serialized_start=513
-  _globals['_LISTVALUE']._serialized_end=572
-# @@protoc_insertion_point(module_scope)

package/templates/python/venv/lib/python3.12/site-packages/google/protobuf/symbol_database.py

@@ -1,179 +0,0 @@
-# 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
-
-"""A database of Python protocol buffer generated symbols.
-
-SymbolDatabase is the MessageFactory for messages generated at compile time,
-and makes it easy to create new instances of a registered type, given only the
-type's protocol buffer symbol name.
-
-Example usage::
-
-  db = symbol_database.SymbolDatabase()
-
-  # Register symbols of interest, from one or multiple files.
-  db.RegisterFileDescriptor(my_proto_pb2.DESCRIPTOR)
-  db.RegisterMessage(my_proto_pb2.MyMessage)
-  db.RegisterEnumDescriptor(my_proto_pb2.MyEnum.DESCRIPTOR)
-
-  # The database can be used as a MessageFactory, to generate types based on
-  # their name:
-  types = db.GetMessages(['my_proto.proto'])
-  my_message_instance = types['MyMessage']()
-
-  # The database's underlying descriptor pool can be queried, so it's not
-  # necessary to know a type's filename to be able to generate it:
-  filename = db.pool.FindFileContainingSymbol('MyMessage')
-  my_message_instance = db.GetMessages([filename])['MyMessage']()
-
-  # This functionality is also provided directly via a convenience method:
-  my_message_instance = db.GetSymbol('MyMessage')()
-"""
-
-import warnings
-
-from google.protobuf.internal import api_implementation
-from google.protobuf import descriptor_pool
-from google.protobuf import message_factory
-
-
-class SymbolDatabase():
-  """A database of Python generated symbols."""
-
-  # local cache of registered classes.
-  _classes = {}
-
-  def __init__(self, pool=None):
-    """Initializes a new SymbolDatabase."""
-    self.pool = pool or descriptor_pool.DescriptorPool()
-
-  def RegisterMessage(self, message):
-    """Registers the given message type in the local database.
-
-    Calls to GetSymbol() and GetMessages() will return messages registered here.
-
-    Args:
-      message: A :class:`google.protobuf.message.Message` subclass (or
-        instance); its descriptor will be registered.
-
-    Returns:
-      The provided message.
-    """
-
-    desc = message.DESCRIPTOR
-    self._classes[desc] = message
-    self.RegisterMessageDescriptor(desc)
-    return message
-
-  def RegisterMessageDescriptor(self, message_descriptor):
-    """Registers the given message descriptor in the local database.
-
-    Args:
-      message_descriptor (Descriptor): the message descriptor to add.
-    """
-    if api_implementation.Type() == 'python':
-      # pylint: disable=protected-access
-      self.pool._AddDescriptor(message_descriptor)
-
-  def RegisterEnumDescriptor(self, enum_descriptor):
-    """Registers the given enum descriptor in the local database.
-
-    Args:
-      enum_descriptor (EnumDescriptor): The enum descriptor to register.
-
-    Returns:
-      EnumDescriptor: The provided descriptor.
-    """
-    if api_implementation.Type() == 'python':
-      # pylint: disable=protected-access
-      self.pool._AddEnumDescriptor(enum_descriptor)
-    return enum_descriptor
-
-  def RegisterServiceDescriptor(self, service_descriptor):
-    """Registers the given service descriptor in the local database.
-
-    Args:
-      service_descriptor (ServiceDescriptor): the service descriptor to
-        register.
-    """
-    if api_implementation.Type() == 'python':
-      # pylint: disable=protected-access
-      self.pool._AddServiceDescriptor(service_descriptor)
-
-  def RegisterFileDescriptor(self, file_descriptor):
-    """Registers the given file descriptor in the local database.
-
-    Args:
-      file_descriptor (FileDescriptor): The file descriptor to register.
-    """
-    if api_implementation.Type() == 'python':
-      # pylint: disable=protected-access
-      self.pool._InternalAddFileDescriptor(file_descriptor)
-
-  def GetSymbol(self, symbol):
-    """Tries to find a symbol in the local database.
-
-    Currently, this method only returns message.Message instances, however, if
-    may be extended in future to support other symbol types.
-
-    Args:
-      symbol (str): a protocol buffer symbol.
-
-    Returns:
-      A Python class corresponding to the symbol.
-
-    Raises:
-      KeyError: if the symbol could not be found.
-    """
-
-    return self._classes[self.pool.FindMessageTypeByName(symbol)]
-
-  def GetMessages(self, files):
-    # TODO: Fix the differences with MessageFactory.
-    """Gets all registered messages from a specified file.
-
-    Only messages already created and registered will be returned; (this is the
-    case for imported _pb2 modules)
-    But unlike MessageFactory, this version also returns already defined nested
-    messages, but does not register any message extensions.
-
-    Args:
-      files (list[str]): The file names to extract messages from.
-
-    Returns:
-      A dictionary mapping proto names to the message classes.
-
-    Raises:
-      KeyError: if a file could not be found.
-    """
-
-    def _GetAllMessages(desc):
-      """Walk a message Descriptor and recursively yields all message names."""
-      yield desc
-      for msg_desc in desc.nested_types:
-        for nested_desc in _GetAllMessages(msg_desc):
-          yield nested_desc
-
-    result = {}
-    for file_name in files:
-      file_desc = self.pool.FindFileByName(file_name)
-      for msg_desc in file_desc.message_types_by_name.values():
-        for desc in _GetAllMessages(msg_desc):
-          try:
-            result[desc.full_name] = self._classes[desc]
-          except KeyError:
-            # This descriptor has no registered class, skip it.
-            pass
-    return result
-
-
-_DEFAULT = SymbolDatabase(pool=descriptor_pool.Default())
-
-
-def Default():
-  """Returns the default SymbolDatabase."""
-  return _DEFAULT

package/templates/python/venv/lib/python3.12/site-packages/google/protobuf/text_encoding.py

@@ -1,106 +0,0 @@
-# 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
-
-"""Encoding related utilities."""
-import re
-
-def _AsciiIsPrint(i):
-  return i >= 32 and i < 127
-
-def _MakeStrEscapes():
-  ret = {}
-  for i in range(0, 128):
-    if not _AsciiIsPrint(i):
-      ret[i] = r'\%03o' % i
-  ret[ord('\t')] = r'\t'  # optional escape
-  ret[ord('\n')] = r'\n'  # optional escape
-  ret[ord('\r')] = r'\r'  # optional escape
-  ret[ord('"')] = r'\"'  # necessary escape
-  ret[ord('\'')] = r"\'"  # optional escape
-  ret[ord('\\')] = r'\\'  # necessary escape
-  return ret
-
-# Maps int -> char, performing string escapes.
-_str_escapes = _MakeStrEscapes()
-
-# Maps int -> char, performing byte escaping and string escapes
-_byte_escapes = {i: chr(i) for i in range(0, 256)}
-_byte_escapes.update(_str_escapes)
-_byte_escapes.update({i: r'\%03o' % i for i in range(128, 256)})
-
-
-def _DecodeUtf8EscapeErrors(text_bytes):
-  ret = ''
-  while text_bytes:
-    try:
-      ret += text_bytes.decode('utf-8').translate(_str_escapes)
-      text_bytes = ''
-    except UnicodeDecodeError as e:
-      ret += text_bytes[:e.start].decode('utf-8').translate(_str_escapes)
-      ret += _byte_escapes[text_bytes[e.start]]
-      text_bytes = text_bytes[e.start+1:]
-  return ret
-
-
-def CEscape(text, as_utf8) -> str:
-  """Escape a bytes string for use in an text protocol buffer.
-
-  Args:
-    text: A byte string to be escaped.
-    as_utf8: Specifies if result may contain non-ASCII characters.
-        In Python 3 this allows unescaped non-ASCII Unicode characters.
-        In Python 2 the return value will be valid UTF-8 rather than only ASCII.
-  Returns:
-    Escaped string (str).
-  """
-  # Python's text.encode() 'string_escape' or 'unicode_escape' codecs do not
-  # satisfy our needs; they encodes unprintable characters using two-digit hex
-  # escapes whereas our C++ unescaping function allows hex escapes to be any
-  # length.  So, "\0011".encode('string_escape') ends up being "\\x011", which
-  # will be decoded in C++ as a single-character string with char code 0x11.
-  text_is_unicode = isinstance(text, str)
-  if as_utf8:
-    if text_is_unicode:
-      return text.translate(_str_escapes)
-    else:
-      return _DecodeUtf8EscapeErrors(text)
-  else:
-    if text_is_unicode:
-      text = text.encode('utf-8')
-    return ''.join([_byte_escapes[c] for c in text])
-
-
-_CUNESCAPE_HEX = re.compile(r'(\\+)x([0-9a-fA-F])(?![0-9a-fA-F])')
-
-
-def CUnescape(text: str) -> bytes:
-  """Unescape a text string with C-style escape sequences to UTF-8 bytes.
-
-  Args:
-    text: The data to parse in a str.
-  Returns:
-    A byte string.
-  """
-
-  def ReplaceHex(m):
-    # Only replace the match if the number of leading back slashes is odd. i.e.
-    # the slash itself is not escaped.
-    if len(m.group(1)) & 1:
-      return m.group(1) + 'x0' + m.group(2)
-    return m.group(0)
-
-  # This is required because the 'string_escape' encoding doesn't
-  # allow single-digit hex escapes (like '\xf').
-  result = _CUNESCAPE_HEX.sub(ReplaceHex, text)
-
-  # Replaces Unicode escape sequences with their character equivalents.
-  result = result.encode('raw_unicode_escape').decode('raw_unicode_escape')
-  # Encode Unicode characters as UTF-8, then decode to Latin-1 escaping
-  # unprintable characters.
-  result = result.encode('utf-8').decode('unicode_escape')
-  # Convert Latin-1 text back to a byte string (latin-1 codec also works here).
-  return result.encode('latin-1')