File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/marshal.tar
Back
__pycache__/compat.cpython-310.pyc 0000644 00000001543 15030365350 0012743 0 ustar 00 o �h- � @ s� d dl mZ zd dlmZ W n ey dZY nw zd dlmZ W n ey- dZY nw ejfZ ej fZ ej fZ dZeefD ]"Zerbe ejf7 Z e ejf7 Z ze ejf7 Z W q@ eya Y q@w q@dZdS )� )� containers)�_messageN)�MessageMapContainer)�repeated_composite_types�repeated_scalar_types�map_composite_types�map_composite_type_names)�google.protobuf.internalr � google._upbr � _message_upb� ImportError�google.protobuf.pyext�_message_pyext� RepeatedCompositeFieldContainerr � RepeatedScalarFieldContainerr � MessageMapr r �message�RepeatedCompositeContainer�RepeatedScalarContainerr �AttributeError�__all__� r r �G/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/compat.py�<module> s4 � � �� __pycache__/__init__.cpython-310.pyc 0000644 00000000334 15030365350 0013214 0 ustar 00 o �hv � @ s d dl mZ dZdS )� )�MarshalN)�marshalr �__all__� r r �I/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/__init__.py�<module> s __pycache__/marshal.cpython-310.pyc 0000644 00000020716 15030365350 0013112 0 ustar 00 o �h�. � @ s" d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dl m Z d d l m Z d d l m Z d d l mZ d d lmZ d d lmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ G dd� de j�ZG dd� d�ZG dd� de�Z G dd� d�Z dZ dS ) � N)�message)� duration_pb2)� timestamp_pb2)�field_mask_pb2)� struct_pb2)� wrappers_pb2)�compat)� MapComposite)�Repeated)�RepeatedComposite)�bytes)�stringy_numbers)�dates)�struct)�wrappers)� field_mask)� ProtoTypec @ s e Zd ZdZedd� �ZdS )�Rulez,Abstract class definition for marshal rules.c C s t |d�r t |d�r dS tS )N� to_python�to_protoT)�hasattr�NotImplemented)�cls�C� r �H/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/marshal.py�__subclasshook__* s zRule.__subclasshook__N)�__name__� __module__� __qualname__�__doc__� classmethodr r r r r r ' s r c @ sd e Zd ZdZdd� Zddedefdd�Zd d � Zd d � Z dd �de fdd�Z dd�de fdd�Z dS )� BaseMarshala� The base class to translate between protobuf and Python classes. Protocol buffers defines many common types (e.g. Timestamp, Duration) which also exist in the Python standard library. The marshal essentially translates between these: it keeps a registry of common protocol buffers and their Python representations, and translates back and forth. The protocol buffer class is always the "key" in this relationship; when presenting a message, the declared field types are used to determine whether a value should be transformed into another class. Similarly, when accepting a Python value (when setting a field, for example), the declared field type is still used. This means that, if appropriate, multiple protocol buffer types may use the same Python type. The primary implementation of this is :class:`Marshal`, which should usually be used instead of this class directly. c C s i | _ t� | _| �� d S �N)�_rules�NoopRule�_noop�reset)�selfr r r �__init__D s zBaseMarshal.__init__N� proto_type�rulec s< |rt |t�s td��|�j� < dS dtf� �fdd� }|S )a� Register a rule against the given ``proto_type``. This function expects a ``proto_type`` (the descriptor class) and a ``rule``; an object with a ``to_python`` and ``to_proto`` method. Each method should return the appropriate Python or protocol buffer type, and be idempotent (e.g. accept either type as input). This function can also be used as a decorator:: @marshal.register(timestamp_pb2.Timestamp) class TimestampRule: ... In this case, the class will be initialized for you with zero arguments. Args: proto_type (type): A protocol buffer message type. rule: A marshal object zIMarshal rule instances must implement `to_proto` and `to_python` methods.N� rule_classc s" t | t�s td��| � �j� < | S )NzJMarshal rule subclasses must implement `to_proto` and `to_python` methods.)� issubclassr � TypeErrorr$ )r, �r* r( r r �register_rule_classm s � z1BaseMarshal.register.<locals>.register_rule_class)� isinstancer r. r$ �type)r( r* r+ r0 r r/ r �registerI s � zBaseMarshal.registerc C sV | j �� | �tjt�� � | �tjt� � � | �t j t � � � | �tjt�� � | �tjt�� � | �tjt�� � | �tjt�� � | �tjt�� � | �tjt�� � | �tj t� � � | �tj t� � � | �tj t�!� � | �t"j#t$j%| d�� | �t"j&t$j'| d�� | �t"j(t$j)| d�� | �t*j+t,�-� � t.j/D ] }| �|j0|� � q�dS )z(Reset the registry to its initial state.��marshalN)1r$ �clearr3 r � Timestampr � TimestampRuler �Duration� DurationRuler � FieldMaskr � FieldMaskRuler � BoolValuer � BoolValueRule� BytesValue�BytesValueRule� DoubleValue�DoubleValueRule� FloatValue�FloatValueRule� Int32Value�Int32ValueRule� Int64Value�Int64ValueRule� StringValue�StringValueRule� UInt32Value�UInt32ValueRule� UInt64Value�UInt64ValueRuler �Valuer � ValueRule� ListValue� ListValueRule�Struct� StructRuler �BYTES�pb_bytes� BytesRuler �STRINGY_NUMBER_RULES� _proto_type)r( r, r r r r' { s( �zBaseMarshal.resetc C s\ | j �|| j�}|| jkr,t| d�r,| j�� D ]\}}|j �|| j�}|| jkr+ |S q|S )N� _instances)r$ �getr& r rZ �items)r( r* r+ �_�instancer r r �get_rule� s �zBaseMarshal.get_rule��absentra c C s� t |�}|tjv rt|| d�S |tjv r&t|t �r t|| |d�S t|| d�S |tjv s1|jtj v r7t || d�S | j |d�j ||d�S )Nr4 )r5 r* �r* r` ) r2 r �repeated_composite_typesr �repeated_scalar_typesr1 r �map_composite_typesr �map_composite_type_namesr r_ r )r( r* �valuera � value_typer r r r � s zBaseMarshal.to_pythonF)�strictri c s� � t jt jt jfvr)t|ttf�r|jS t|tt f�r)t |�� �fdd�|D ��S t|t �rJ� j j rJ� j �� jrJt � � j����fdd�|�� D �S �j� d��|�}|rft|� �sftdj� j|jjd���|S )Nc 3 s � | ] }�� � |�V qd S r# �r )�.0�ir/ r r � <genexpr>� s � z'BaseMarshal.to_proto.<locals>.<genexpr>c s i | ] \}}|�� � |��qS r rj )rk �k�v)�recursive_typer( r r � <dictcomp>� s z(BaseMarshal.to_proto.<locals>.<dictcomp>rb zLParameter must be instance of the same class; expected {expected}, got {got})�expected�got)r rO rQ rS r1 r r �pb�list�tupler2 �dict� DESCRIPTOR� has_options� GetOptions� map_entryrg r\ r_ r r. �formatr � __class__)r( r* rg ri �pb_valuer )r* rp r( r r � s4 � � � ��zBaseMarshal.to_protor# ) r r r r r) r2 r r3 r' r_ �boolr r r r r r r" 1 s 2'r" c s< e Zd ZdZi Zdef� fdd� Zdef� fdd� Z� ZS )�Marshala The translator between protocol buffer and Python instances. The bulk of the implementation is in :class:`BaseMarshal`. This class adds identity tracking: multiple instantiations of :class:`Marshal` with the same name will provide the same instance. �namec s. | j �|�}|du rt� �| � }| j |< |S )z�Create a marshal instance. Args: name (str): The name of the marshal. Instantiating multiple marshals with the same ``name`` argument will provide the same marshal each time. N)rZ r[ �super�__new__)r r� �klass�r} r r r� s zMarshal.__new__c s" || _ t| d�st� �� dS dS )z�Instantiate a marshal. Args: name (str): The name of the marshal. Instantiating multiple marshals with the same ``name`` argument will provide the same marshal each time. r$ N)�_namer r� r) )r( r� r� r r r) s �zMarshal.__init__) r r r r rZ �strr� r) � __classcell__r r r� r r� � s r� c @ s, e Zd ZdZdd�defdd�Zdd� ZdS ) r% z#A catch-all rule that does nothing.Nr` ra c C � |S r# r )r( r~ ra r r r r " � zNoopRule.to_pythonc C r� r# r )r( rg r r r r % r� zNoopRule.to_proto)r r r r r r r r r r r r% s r% )r� ) �abc�enum�google.protobufr r r r r r � proto.marshalr �proto.marshal.collectionsr r r �proto.marshal.rulesr rV r r r r r �proto.primitivesr �ABCr r" r� r% �__all__r r r r �<module> s2 J% marshal.py 0000644 00000027376 15030365350 0006564 0 ustar 00 # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import abc import enum from google.protobuf import message from google.protobuf import duration_pb2 from google.protobuf import timestamp_pb2 from google.protobuf import field_mask_pb2 from google.protobuf import struct_pb2 from google.protobuf import wrappers_pb2 from proto.marshal import compat from proto.marshal.collections import MapComposite from proto.marshal.collections import Repeated from proto.marshal.collections import RepeatedComposite from proto.marshal.rules import bytes as pb_bytes from proto.marshal.rules import stringy_numbers from proto.marshal.rules import dates from proto.marshal.rules import struct from proto.marshal.rules import wrappers from proto.marshal.rules import field_mask from proto.primitives import ProtoType class Rule(abc.ABC): """Abstract class definition for marshal rules.""" @classmethod def __subclasshook__(cls, C): if hasattr(C, "to_python") and hasattr(C, "to_proto"): return True return NotImplemented class BaseMarshal: """The base class to translate between protobuf and Python classes. Protocol buffers defines many common types (e.g. Timestamp, Duration) which also exist in the Python standard library. The marshal essentially translates between these: it keeps a registry of common protocol buffers and their Python representations, and translates back and forth. The protocol buffer class is always the "key" in this relationship; when presenting a message, the declared field types are used to determine whether a value should be transformed into another class. Similarly, when accepting a Python value (when setting a field, for example), the declared field type is still used. This means that, if appropriate, multiple protocol buffer types may use the same Python type. The primary implementation of this is :class:`Marshal`, which should usually be used instead of this class directly. """ def __init__(self): self._rules = {} self._noop = NoopRule() self.reset() def register(self, proto_type: type, rule: Rule = None): """Register a rule against the given ``proto_type``. This function expects a ``proto_type`` (the descriptor class) and a ``rule``; an object with a ``to_python`` and ``to_proto`` method. Each method should return the appropriate Python or protocol buffer type, and be idempotent (e.g. accept either type as input). This function can also be used as a decorator:: @marshal.register(timestamp_pb2.Timestamp) class TimestampRule: ... In this case, the class will be initialized for you with zero arguments. Args: proto_type (type): A protocol buffer message type. rule: A marshal object """ # If a rule was provided, register it and be done. if rule: # Ensure the rule implements Rule. if not isinstance(rule, Rule): raise TypeError( "Marshal rule instances must implement " "`to_proto` and `to_python` methods." ) # Register the rule. self._rules[proto_type] = rule return # Create an inner function that will register an instance of the # marshal class to this object's registry, and return it. def register_rule_class(rule_class: type): # Ensure the rule class is a valid rule. if not issubclass(rule_class, Rule): raise TypeError( "Marshal rule subclasses must implement " "`to_proto` and `to_python` methods." ) # Register the rule class. self._rules[proto_type] = rule_class() return rule_class return register_rule_class def reset(self): """Reset the registry to its initial state.""" self._rules.clear() # Register date and time wrappers. self.register(timestamp_pb2.Timestamp, dates.TimestampRule()) self.register(duration_pb2.Duration, dates.DurationRule()) # Register FieldMask wrappers. self.register(field_mask_pb2.FieldMask, field_mask.FieldMaskRule()) # Register nullable primitive wrappers. self.register(wrappers_pb2.BoolValue, wrappers.BoolValueRule()) self.register(wrappers_pb2.BytesValue, wrappers.BytesValueRule()) self.register(wrappers_pb2.DoubleValue, wrappers.DoubleValueRule()) self.register(wrappers_pb2.FloatValue, wrappers.FloatValueRule()) self.register(wrappers_pb2.Int32Value, wrappers.Int32ValueRule()) self.register(wrappers_pb2.Int64Value, wrappers.Int64ValueRule()) self.register(wrappers_pb2.StringValue, wrappers.StringValueRule()) self.register(wrappers_pb2.UInt32Value, wrappers.UInt32ValueRule()) self.register(wrappers_pb2.UInt64Value, wrappers.UInt64ValueRule()) # Register the google.protobuf.Struct wrappers. # # These are aware of the marshal that created them, because they # create RepeatedComposite and MapComposite instances directly and # need to pass the marshal to them. self.register(struct_pb2.Value, struct.ValueRule(marshal=self)) self.register(struct_pb2.ListValue, struct.ListValueRule(marshal=self)) self.register(struct_pb2.Struct, struct.StructRule(marshal=self)) # Special case for bytes to allow base64 encode/decode self.register(ProtoType.BYTES, pb_bytes.BytesRule()) # Special case for int64 from strings because of dict round trip. # See https://github.com/protocolbuffers/protobuf/issues/2679 for rule_class in stringy_numbers.STRINGY_NUMBER_RULES: self.register(rule_class._proto_type, rule_class()) def get_rule(self, proto_type): # Rules are needed to convert values between proto-plus and pb. # Retrieve the rule for the specified proto type. # The NoopRule will be used when a rule is not found. rule = self._rules.get(proto_type, self._noop) # If we don't find a rule, also check under `_instances` # in case there is a rule in another package. # See https://github.com/googleapis/proto-plus-python/issues/349 if rule == self._noop and hasattr(self, "_instances"): for _, instance in self._instances.items(): rule = instance._rules.get(proto_type, self._noop) if rule != self._noop: break return rule def to_python(self, proto_type, value, *, absent: bool = None): # Internal protobuf has its own special type for lists of values. # Return a view around it that implements MutableSequence. value_type = type(value) # Minor performance boost over isinstance if value_type in compat.repeated_composite_types: return RepeatedComposite(value, marshal=self) if value_type in compat.repeated_scalar_types: if isinstance(proto_type, type): return RepeatedComposite(value, marshal=self, proto_type=proto_type) else: return Repeated(value, marshal=self) # Same thing for maps of messages. # See https://github.com/protocolbuffers/protobuf/issues/16596 # We need to look up the name of the type in compat.map_composite_type_names # as class `MessageMapContainer` is no longer exposed # This is done to avoid taking a breaking change in proto-plus. if ( value_type in compat.map_composite_types or value_type.__name__ in compat.map_composite_type_names ): return MapComposite(value, marshal=self) return self.get_rule(proto_type=proto_type).to_python(value, absent=absent) def to_proto(self, proto_type, value, *, strict: bool = False): # The protos in google/protobuf/struct.proto are exceptional cases, # because they can and should represent themselves as lists and dicts. # These cases are handled in their rule classes. if proto_type not in ( struct_pb2.Value, struct_pb2.ListValue, struct_pb2.Struct, ): # For our repeated and map view objects, simply return the # underlying pb. if isinstance(value, (Repeated, MapComposite)): return value.pb # Convert lists and tuples recursively. if isinstance(value, (list, tuple)): return type(value)(self.to_proto(proto_type, i) for i in value) # Convert dictionaries recursively when the proto type is a map. # This is slightly more complicated than converting a list or tuple # because we have to step through the magic that protocol buffers does. # # Essentially, a type of map<string, Foo> will show up here as # a FoosEntry with a `key` field, `value` field, and a `map_entry` # annotation. We need to do the conversion based on the `value` # field's type. if isinstance(value, dict) and ( proto_type.DESCRIPTOR.has_options and proto_type.DESCRIPTOR.GetOptions().map_entry ): recursive_type = type(proto_type().value) return {k: self.to_proto(recursive_type, v) for k, v in value.items()} pb_value = self.get_rule(proto_type=proto_type).to_proto(value) # Sanity check: If we are in strict mode, did we get the value we want? if strict and not isinstance(pb_value, proto_type): raise TypeError( "Parameter must be instance of the same class; " "expected {expected}, got {got}".format( expected=proto_type.__name__, got=pb_value.__class__.__name__, ), ) # Return the final value. return pb_value class Marshal(BaseMarshal): """The translator between protocol buffer and Python instances. The bulk of the implementation is in :class:`BaseMarshal`. This class adds identity tracking: multiple instantiations of :class:`Marshal` with the same name will provide the same instance. """ _instances = {} def __new__(cls, *, name: str): """Create a marshal instance. Args: name (str): The name of the marshal. Instantiating multiple marshals with the same ``name`` argument will provide the same marshal each time. """ klass = cls._instances.get(name) if klass is None: klass = cls._instances[name] = super().__new__(cls) return klass def __init__(self, *, name: str): """Instantiate a marshal. Args: name (str): The name of the marshal. Instantiating multiple marshals with the same ``name`` argument will provide the same marshal each time. """ self._name = name if not hasattr(self, "_rules"): super().__init__() class NoopRule: """A catch-all rule that does nothing.""" def to_python(self, pb_value, *, absent: bool = None): return pb_value def to_proto(self, value): return value __all__ = ("Marshal",) rules/__pycache__/bytes.cpython-310.pyc 0000644 00000002632 15030365350 0013740 0 ustar 00 o �h9 � @ s d dl Z G dd� d�ZdS )� Nc @ s, e Zd ZdZdd�defdd�Zdd� ZdS ) � BytesRulea� A marshal between Python strings and protobuf bytes. Note: this conversion is asymmetric because Python does have a bytes type. It is sometimes necessary to convert proto bytes fields to strings, e.g. for JSON encoding, marshalling a message to a dict. Because bytes fields can represent arbitrary data, bytes fields are base64 encoded when they need to be represented as strings. It is necessary to have the conversion be bidirectional, i.e. my_message == MyMessage(MyMessage.to_dict(my_message)) To accomplish this, we need to intercept assignments from strings and base64 decode them back into bytes. N)�absentr c C s |S )N� )�self�valuer r r �L/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/rules/bytes.py� to_python# s zBytesRule.to_pythonc C s: t |t�r|�d�}|ddt|�d 7 }t�|�}|S )Nzutf-8� =� )� isinstance�str�encode�len�base64�urlsafe_b64decode)r r r r r �to_proto& s zBytesRule.to_proto)�__name__� __module__� __qualname__�__doc__�boolr r r r r r r s r )r r r r r r �<module> s rules/__pycache__/message.cpython-310.pyc 0000644 00000002647 15030365350 0014244 0 ustar 00 o �h< � @ s G d d� d�Z dS )c @ sJ e Zd ZdZdedefdd�Zdd�defd d �Zd d � Ze d d� �Z dS )� MessageRulez@A marshal for converting between a descriptor and proto.Message.� descriptor�wrapperc C s || _ || _d S �N)� _descriptor�_wrapper)�selfr r � r �N/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/rules/message.py�__init__ s zMessageRule.__init__N)�absentr c C s t || j�r | j�|�S |S r )� isinstancer r �wrap)r �valuer r r r � to_python s zMessageRule.to_pythonc C sv t || j�r | j�|�S t |t�r9| js9z | jdi |��W S tttfy8 } z | �|�j W Y d }~S d }~ww |S )Nr ) r r �pb�dict�is_mapr � TypeError� ValueError�AttributeError�_pb)r r �exr r r �to_proto s �� zMessageRule.to_protoc C s | j j}|jo |�� jS )z>Return True if the descriptor is a map entry, False otherwise.)r � DESCRIPTOR� has_options� GetOptions� map_entry)r �descr r r r 1 s zMessageRule.is_map) �__name__� __module__� __qualname__�__doc__�typer �boolr r �propertyr r r r r r s r N)r r r r r �<module> s rules/__pycache__/__init__.cpython-310.pyc 0000644 00000000254 15030365350 0014347 0 ustar 00 o �h? � @ s d S )N� r r r �O/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/rules/__init__.py�<module> s rules/__pycache__/wrappers.cpython-310.pyc 0000644 00000005113 15030365350 0014452 0 ustar 00 o �h� � @ s� d dl mZ G dd� d�ZG dd� de�ZG dd� de�ZG dd � d e�ZG d d � d e�ZG d d � d e�ZG dd� de�ZG dd� de�Z G dd� de�Z G dd� de�Z dS )� )� wrappers_pb2c @ s, e Zd ZdZdd�defdd�Zdd� ZdS ) � WrapperRuleaU A marshal for converting the protobuf wrapper classes to Python. This class converts between ``google.protobuf.BoolValue``, ``google.protobuf.StringValue``, and their siblings to the appropriate Python equivalents. These are effectively similar to the protobuf primitives except that None becomes a possible value. N)�absentr c C s t || j�r |r d S |jS |S )N)� isinstance� _proto_type�value)�selfr r � r �O/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/rules/wrappers.py� to_python s zWrapperRule.to_pythonc C s t || j�r | j|d�S |S )N)r )r � _python_typer )r r r r r �to_proto$ s zWrapperRule.to_proto)�__name__� __module__� __qualname__�__doc__�boolr r r r r r r s r c @ � e Zd ZejZeZdS )�DoubleValueRuleN)r r r r � DoubleValuer �floatr r r r r r * � r c @ r )�FloatValueRuleN)r r r r � FloatValuer r r r r r r r / r r c @ r )�Int64ValueRuleN)r r r r � Int64Valuer �intr r r r r r 4 r r c @ r )�UInt64ValueRuleN)r r r r � UInt64Valuer r r r r r r r 9 r r c @ r )�Int32ValueRuleN)r r r r � Int32Valuer r r r r r r r > r r c @ r )�UInt32ValueRuleN)r r r r � UInt32Valuer r r r r r r r! C r r! c @ r )� BoolValueRuleN)r r r r � BoolValuer r r r r r r r# H r r# c @ r )�StringValueRuleN)r r r r � StringValuer �strr r r r r r% M r r% c @ r )�BytesValueRuleN)r r r r � BytesValuer �bytesr r r r r r( R r r( N) �google.protobufr r r r r r r r! r# r% r( r r r r �<module> s rules/__pycache__/field_mask.cpython-310.pyc 0000644 00000002006 15030365350 0014703 0 ustar 00 o �h� � @ s d dl mZ G dd� d�ZdS )� )�field_mask_pb2c @ s, e Zd ZdZdd�defdd�Zdd� ZdS ) � FieldMaskRulez�A marshal between FieldMask and strings. See https://github.com/googleapis/proto-plus-python/issues/333 and https://developers.google.com/protocol-buffers/docs/proto3#json for more details. N)�absentr c C s |S )N� )�self�valuer r r �Q/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/rules/field_mask.py� to_python s zFieldMaskRule.to_pythonc C s& t |t�rt�� }|j|d� |S |S )N)r )� isinstance�strr � FieldMask�FromJsonString)r r �field_mask_valuer r r �to_proto s zFieldMaskRule.to_proto)�__name__� __module__� __qualname__�__doc__�boolr r r r r r r s r N)�google.protobufr r r r r r �<module> s rules/__pycache__/enums.cpython-310.pyc 0000644 00000002310 15030365350 0013732 0 ustar 00 o �h� � @ s. d dl mZ d dlZd dlZG dd� d�ZdS )� )�TypeNc @ s@ e Zd ZdZdeej fdd�Zdd�defdd �Z d d � Z dS ) �EnumRulez@A marshal for converting between integer values and enum values.� enum_classc C s || _ d S �N)�_enum)�selfr � r �L/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/rules/enums.py�__init__ s zEnumRule.__init__N)�absentr c C sT t |t�r(t || j�s(z| �|�W S ty' t�dj| jj|d�� Y |S w |S )Nz'Unrecognized {name} enum value: {value})�name�value)� isinstance�intr � ValueError�warnings�warn�format�__name__)r r r r r r � to_python s ��� zEnumRule.to_pythonc C s, t || j�r |jS t |t�r| j| jS |S r )r r r �str)r r r r r �to_proto- s zEnumRule.to_proto) r � __module__� __qualname__�__doc__r �enum�IntEnumr �boolr r r r r r r s r )�typingr r r r r r r r �<module> s rules/__pycache__/stringy_numbers.cpython-310.pyc 0000644 00000003612 15030365350 0016043 0 ustar 00 o �h� � @ s| d dl mZ G dd� d�ZG dd� de�ZG dd� de�ZG dd � d e�ZG d d � d e�ZG d d � d e�ZeeeeegZdS )� )� ProtoTypec @ s, e Zd ZdZdd�defdd�Zdd� ZdS ) �StringyNumberRuleaE A marshal between certain numeric types and strings This is a necessary hack to allow round trip conversion from messages to dicts back to messages. See https://github.com/protocolbuffers/protobuf/issues/2679 and https://developers.google.com/protocol-buffers/docs/proto3#json for more details. N)�absentr c C s |S �N� )�self�valuer r r �V/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/rules/stringy_numbers.py� to_python s zStringyNumberRule.to_pythonc C s |d ur | � |�S d S r )� _python_type)r r r r r �to_proto! s zStringyNumberRule.to_proto)�__name__� __module__� __qualname__�__doc__�boolr r r r r r r s r c @ � e Zd ZeZejZdS )� Int64RuleN)r r r �intr r �INT64� _proto_typer r r r r ( � r c @ r )� UInt64RuleN)r r r r r r �UINT64r r r r r r - r r c @ r )� SInt64RuleN)r r r r r r �SINT64r r r r r r 2 r r c @ r )� Fixed64RuleN)r r r r r r �FIXED64r r r r r r 7 r r c @ r )� SFixed64RuleN)r r r r r r �SFIXED64r r r r r r < r r N) �proto.primitivesr r r r r r r �STRINGY_NUMBER_RULESr r r r �<module> s � rules/__pycache__/dates.cpython-310.pyc 0000644 00000005133 15030365350 0013711 0 ustar 00 o �h? � @ sl d dl m Z d dl mZ d dl mZ d dlmZ d dlmZ d dlmZmZ G dd� d�Z G d d � d �Z d S ) � )�datetime)� timedelta)�timezone)� duration_pb2)� timestamp_pb2)�datetime_helpers�utilsc @ s: e Zd ZdZdd�dedejfdd�Zdej fdd �Z dS ) � TimestampRulea& A marshal between Python datetimes and protobuf timestamps. Note: Python datetimes are less precise than protobuf datetimes (microsecond vs. nanosecond level precision). If nanosecond-level precision matters, it is recommended to interact with the internal proto directly. N��absentr �returnc C s$ t |tj�r|r d S tj�|�S |S )N)� isinstancer � Timestampr �DatetimeWithNanoseconds�from_timestamp_pb��self�valuer � r �L/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/rules/dates.py� to_python! s zTimestampRule.to_pythonc C s` t |tj�r |�� S t |t�r tjt|�� �|j d d�S t |t �r.t�� }|j |d� |S |S )N�� ��seconds�nanos�r ) r r r � timestamp_pbr r r �int� timestamp� microsecond�str�FromJsonString)r r �timestamp_valuer r r �to_proto* s � zTimestampRule.to_proto) �__name__� __module__� __qualname__�__doc__�boolr r r r r r# r r r r r s �� � r c @ s8 e Zd ZdZdd�dedefdd�Zdejfdd �Z dS ) � DurationRulea' A marshal between Python timedeltas and protobuf durations. Note: Python timedeltas are less precise than protobuf durations (microsecond vs. nanosecond level precision). If nanosecond-level precision matters, it is recommended to interact with the internal proto directly. Nr r r c C s0 t |tj�rt|jd |jd |jd d�S |S )N�Q r )�daysr � microseconds)r r �Durationr r r r r r r r B s �zDurationRule.to_pythonc C sP t |t�rtj|jd |j |jd d�S t |t�r&t�� }|j|d� |S |S )Nr* r r r ) r r r r- r+ r r, r r! )r r �duration_valuer r r r# K s � zDurationRule.to_proto) r$ r% r& r' r( r r r r- r# r r r r r) 9 s r) N) r r r �google.protobufr r �protor r r r) r r r r �<module> s ! rules/__pycache__/struct.cpython-310.pyc 0000644 00000010414 15030365350 0014133 0 ustar 00 o �hj � @ sZ d dl Zd dlmZ d dlmZ d dlmZ G dd� d�ZG dd� d�ZG d d � d �Z dS ) � N)� struct_pb2)�maps)�repeatedc @ �< e Zd ZdZdd� Zdd�defdd�Zd ejfd d �Z dS ) � ValueRulezBA rule to marshal between google.protobuf.Value and Python values.c C � || _ d S �N��_marshal��self�marshal� r �M/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/rules/struct.py�__init__ � zValueRule.__init__N��absentr c C s� |� d�}|dks |r dS |dkrt|j�S |dkr t|j�S |dkr(t|j�S |dkr7| jjt j |j dd �S |d krF| jjt j |j dd �S td | ��) aB Coerce the given value to the appropriate Python type. Note that both NullValue and absent fields return None. In order to disambiguate between these two options, use containment check, E.g. "value" in foo which is True for NullValue and False for an absent value. �kind� null_valueN� bool_value� number_value� string_value� struct_valueFr � list_valuezUnexpected kind: %s)� WhichOneof�boolr �floatr �strr r � to_pythonr �Structr � ListValuer � ValueError)r �valuer r r r r r s, �� zValueRule.to_python�returnc C s� t |tj�r|S |du rtjdd�S t |t�r tj|d�S t |ttf�r,tjt|�d�S t |t�r7tj|d�S t |tjj �rJtj| j � tj |�d�S t |tjj �r]tj| j � tj|�d�S td | ��) z7Return a protobuf Value object representing this value.Nr )r )r )r )r )r )r zUnable to coerce value: %r)� isinstancer �Valuer �intr r � collections�abc�Sequencer �to_protor! �Mappingr r" �r r# r r r r+ @ s& �� zValueRule.to_proto) �__name__� __module__� __qualname__�__doc__r r r r r& r+ r r r r r s #r c @ r ) � ListValueRulezCA rule translating google.protobuf.ListValue and list-like objects.c C r r r r r r r r Z r zListValueRule.__init__Nr r c C � |rdS t j|j| jd�S )z,Coerce the given value to a Python sequence.N�r )r �RepeatedComposite�valuesr �r r# r r r r r ] s ���zListValueRule.to_pythonr$ c sN t |tj�r|S t |tj�rtjdd� |jD �d�S tj� fdd�|D �d�S )Nc S s g | ]}|�qS r r ��.0�vr r r � <listcomp>k s z*ListValueRule.to_proto.<locals>.<listcomp>)r6 c s g | ] }� j �tj|��qS r �r r+ r r& r8 �r r r r; o s )r% r r! r r5 �pbr- r r= r r+ e s �zListValueRule.to_proto) r. r/ r0 r1 r r r r r! r+ r r r r r2 W s r2 c @ r ) � StructRulez@A rule translating google.protobuf.Struct and dict-like objects.c C r r r r r r r r v r zStructRule.__init__Nr r c C r3 )z+Coerce the given value to a Python mapping.Nr4 )r � MapComposite�fieldsr r7 r r r r y s ��zStructRule.to_pythonr$ c sZ t |tj�r|S t |tj�r tjdd� |j�� D �d�S tj� fdd�|�� D �d�}|S )Nc S s i | ]\}}||�qS r r �r9 �kr: r r r � <dictcomp>� s z'StructRule.to_proto.<locals>.<dictcomp>)rA c s" i | ] \}}|� j �tj|��qS r r< rB r= r r rD � s �)r% r r r r@ r> �items)r r# �answerr r= r r+ s � ��zStructRule.to_proto) r. r/ r0 r1 r r r r r r+ r r r r r? s s r? ) �collections.abcr( �google.protobufr �proto.marshal.collectionsr r r r2 r? r r r r �<module> s @ rules/message.py 0000644 00000004474 15030365350 0007705 0 ustar 00 # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. class MessageRule: """A marshal for converting between a descriptor and proto.Message.""" def __init__(self, descriptor: type, wrapper: type): self._descriptor = descriptor self._wrapper = wrapper def to_python(self, value, *, absent: bool = None): if isinstance(value, self._descriptor): return self._wrapper.wrap(value) return value def to_proto(self, value): if isinstance(value, self._wrapper): return self._wrapper.pb(value) if isinstance(value, dict) and not self.is_map: # We need to use the wrapper's marshaling to handle # potentially problematic nested messages. try: # Try the fast path first. return self._descriptor(**value) except (TypeError, ValueError, AttributeError) as ex: # If we have a TypeError, ValueError or AttributeError, # try the slow path in case the error # was: # - an int64/string issue. # - a missing key issue in case a key only exists with a `_` suffix. # See related issue: https://github.com/googleapis/python-api-core/issues/227. # - a missing key issue due to nested struct. See: https://github.com/googleapis/proto-plus-python/issues/424. # - a missing key issue due to nested duration. See: https://github.com/googleapis/google-cloud-python/issues/13350. return self._wrapper(value)._pb return value @property def is_map(self): """Return True if the descriptor is a map entry, False otherwise.""" desc = self._descriptor.DESCRIPTOR return desc.has_options and desc.GetOptions().map_entry rules/stringy_numbers.py 0000644 00000003373 15030365350 0011510 0 ustar 00 # Copyright (C) 2021 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from proto.primitives import ProtoType class StringyNumberRule: """A marshal between certain numeric types and strings This is a necessary hack to allow round trip conversion from messages to dicts back to messages. See https://github.com/protocolbuffers/protobuf/issues/2679 and https://developers.google.com/protocol-buffers/docs/proto3#json for more details. """ def to_python(self, value, *, absent: bool = None): return value def to_proto(self, value): if value is not None: return self._python_type(value) return None class Int64Rule(StringyNumberRule): _python_type = int _proto_type = ProtoType.INT64 class UInt64Rule(StringyNumberRule): _python_type = int _proto_type = ProtoType.UINT64 class SInt64Rule(StringyNumberRule): _python_type = int _proto_type = ProtoType.SINT64 class Fixed64Rule(StringyNumberRule): _python_type = int _proto_type = ProtoType.FIXED64 class SFixed64Rule(StringyNumberRule): _python_type = int _proto_type = ProtoType.SFIXED64 STRINGY_NUMBER_RULES = [ Int64Rule, UInt64Rule, SInt64Rule, Fixed64Rule, SFixed64Rule, ] rules/struct.py 0000644 00000012152 15030365350 0007575 0 ustar 00 # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import collections.abc from google.protobuf import struct_pb2 from proto.marshal.collections import maps from proto.marshal.collections import repeated class ValueRule: """A rule to marshal between google.protobuf.Value and Python values.""" def __init__(self, *, marshal): self._marshal = marshal def to_python(self, value, *, absent: bool = None): """Coerce the given value to the appropriate Python type. Note that both NullValue and absent fields return None. In order to disambiguate between these two options, use containment check, E.g. "value" in foo which is True for NullValue and False for an absent value. """ kind = value.WhichOneof("kind") if kind == "null_value" or absent: return None if kind == "bool_value": return bool(value.bool_value) if kind == "number_value": return float(value.number_value) if kind == "string_value": return str(value.string_value) if kind == "struct_value": return self._marshal.to_python( struct_pb2.Struct, value.struct_value, absent=False, ) if kind == "list_value": return self._marshal.to_python( struct_pb2.ListValue, value.list_value, absent=False, ) # If more variants are ever added, we want to fail loudly # instead of tacitly returning None. raise ValueError("Unexpected kind: %s" % kind) # pragma: NO COVER def to_proto(self, value) -> struct_pb2.Value: """Return a protobuf Value object representing this value.""" if isinstance(value, struct_pb2.Value): return value if value is None: return struct_pb2.Value(null_value=0) if isinstance(value, bool): return struct_pb2.Value(bool_value=value) if isinstance(value, (int, float)): return struct_pb2.Value(number_value=float(value)) if isinstance(value, str): return struct_pb2.Value(string_value=value) if isinstance(value, collections.abc.Sequence): return struct_pb2.Value( list_value=self._marshal.to_proto(struct_pb2.ListValue, value), ) if isinstance(value, collections.abc.Mapping): return struct_pb2.Value( struct_value=self._marshal.to_proto(struct_pb2.Struct, value), ) raise ValueError("Unable to coerce value: %r" % value) class ListValueRule: """A rule translating google.protobuf.ListValue and list-like objects.""" def __init__(self, *, marshal): self._marshal = marshal def to_python(self, value, *, absent: bool = None): """Coerce the given value to a Python sequence.""" return ( None if absent else repeated.RepeatedComposite(value.values, marshal=self._marshal) ) def to_proto(self, value) -> struct_pb2.ListValue: # We got a proto, or else something we sent originally. # Preserve the instance we have. if isinstance(value, struct_pb2.ListValue): return value if isinstance(value, repeated.RepeatedComposite): return struct_pb2.ListValue(values=[v for v in value.pb]) # We got a list (or something list-like); convert it. return struct_pb2.ListValue( values=[self._marshal.to_proto(struct_pb2.Value, v) for v in value] ) class StructRule: """A rule translating google.protobuf.Struct and dict-like objects.""" def __init__(self, *, marshal): self._marshal = marshal def to_python(self, value, *, absent: bool = None): """Coerce the given value to a Python mapping.""" return ( None if absent else maps.MapComposite(value.fields, marshal=self._marshal) ) def to_proto(self, value) -> struct_pb2.Struct: # We got a proto, or else something we sent originally. # Preserve the instance we have. if isinstance(value, struct_pb2.Struct): return value if isinstance(value, maps.MapComposite): return struct_pb2.Struct( fields={k: v for k, v in value.pb.items()}, ) # We got a dict (or something dict-like); convert it. answer = struct_pb2.Struct( fields={ k: self._marshal.to_proto(struct_pb2.Value, v) for k, v in value.items() } ) return answer rules/bytes.py 0000644 00000003071 15030365350 0007377 0 ustar 00 # Copyright (C) 2021 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import base64 class BytesRule: """A marshal between Python strings and protobuf bytes. Note: this conversion is asymmetric because Python does have a bytes type. It is sometimes necessary to convert proto bytes fields to strings, e.g. for JSON encoding, marshalling a message to a dict. Because bytes fields can represent arbitrary data, bytes fields are base64 encoded when they need to be represented as strings. It is necessary to have the conversion be bidirectional, i.e. my_message == MyMessage(MyMessage.to_dict(my_message)) To accomplish this, we need to intercept assignments from strings and base64 decode them back into bytes. """ def to_python(self, value, *, absent: bool = None): return value def to_proto(self, value): if isinstance(value, str): value = value.encode("utf-8") value += b"=" * (4 - len(value) % 4) # padding value = base64.urlsafe_b64decode(value) return value rules/field_mask.py 0000644 00000002236 15030365350 0010351 0 ustar 00 # Copyright 2022 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from google.protobuf import field_mask_pb2 class FieldMaskRule: """A marshal between FieldMask and strings. See https://github.com/googleapis/proto-plus-python/issues/333 and https://developers.google.com/protocol-buffers/docs/proto3#json for more details. """ def to_python(self, value, *, absent: bool = None): return value def to_proto(self, value): if isinstance(value, str): field_mask_value = field_mask_pb2.FieldMask() field_mask_value.FromJsonString(value=value) return field_mask_value return value rules/enums.py 0000644 00000004245 15030365350 0007404 0 ustar 00 # Copyright 2019 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import Type import enum import warnings class EnumRule: """A marshal for converting between integer values and enum values.""" def __init__(self, enum_class: Type[enum.IntEnum]): self._enum = enum_class def to_python(self, value, *, absent: bool = None): if isinstance(value, int) and not isinstance(value, self._enum): try: # Coerce the int on the wire to the enum value. return self._enum(value) except ValueError: # Since it is possible to add values to enums, we do # not want to flatly error on this. # # However, it is useful to make some noise about it so # the user realizes that an unexpected value came along. warnings.warn( "Unrecognized {name} enum value: {value}".format( name=self._enum.__name__, value=value, ) ) return value def to_proto(self, value): # Accept enum values and coerce to the pure integer. # This is not strictly necessary (protocol buffers can take these # objects as they subclass int) but nevertheless seems like the # right thing to do. if isinstance(value, self._enum): return value.value # If a string is provided that matches an enum value, coerce it # to the enum value. if isinstance(value, str): return self._enum[value].value # We got a pure integer; pass it on. return value rules/dates.py 0000644 00000006077 15030365350 0007362 0 ustar 00 # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from datetime import datetime from datetime import timedelta from datetime import timezone from google.protobuf import duration_pb2 from google.protobuf import timestamp_pb2 from proto import datetime_helpers, utils class TimestampRule: """A marshal between Python datetimes and protobuf timestamps. Note: Python datetimes are less precise than protobuf datetimes (microsecond vs. nanosecond level precision). If nanosecond-level precision matters, it is recommended to interact with the internal proto directly. """ def to_python( self, value, *, absent: bool = None ) -> datetime_helpers.DatetimeWithNanoseconds: if isinstance(value, timestamp_pb2.Timestamp): if absent: return None return datetime_helpers.DatetimeWithNanoseconds.from_timestamp_pb(value) return value def to_proto(self, value) -> timestamp_pb2.Timestamp: if isinstance(value, datetime_helpers.DatetimeWithNanoseconds): return value.timestamp_pb() if isinstance(value, datetime): return timestamp_pb2.Timestamp( seconds=int(value.timestamp()), nanos=value.microsecond * 1000, ) if isinstance(value, str): timestamp_value = timestamp_pb2.Timestamp() timestamp_value.FromJsonString(value=value) return timestamp_value return value class DurationRule: """A marshal between Python timedeltas and protobuf durations. Note: Python timedeltas are less precise than protobuf durations (microsecond vs. nanosecond level precision). If nanosecond-level precision matters, it is recommended to interact with the internal proto directly. """ def to_python(self, value, *, absent: bool = None) -> timedelta: if isinstance(value, duration_pb2.Duration): return timedelta( days=value.seconds // 86400, seconds=value.seconds % 86400, microseconds=value.nanos // 1000, ) return value def to_proto(self, value) -> duration_pb2.Duration: if isinstance(value, timedelta): return duration_pb2.Duration( seconds=value.days * 86400 + value.seconds, nanos=value.microseconds * 1000, ) if isinstance(value, str): duration_value = duration_pb2.Duration() duration_value.FromJsonString(value=value) return duration_value return value rules/wrappers.py 0000644 00000004350 15030365350 0010115 0 ustar 00 # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from google.protobuf import wrappers_pb2 class WrapperRule: """A marshal for converting the protobuf wrapper classes to Python. This class converts between ``google.protobuf.BoolValue``, ``google.protobuf.StringValue``, and their siblings to the appropriate Python equivalents. These are effectively similar to the protobuf primitives except that None becomes a possible value. """ def to_python(self, value, *, absent: bool = None): if isinstance(value, self._proto_type): if absent: return None return value.value return value def to_proto(self, value): if isinstance(value, self._python_type): return self._proto_type(value=value) return value class DoubleValueRule(WrapperRule): _proto_type = wrappers_pb2.DoubleValue _python_type = float class FloatValueRule(WrapperRule): _proto_type = wrappers_pb2.FloatValue _python_type = float class Int64ValueRule(WrapperRule): _proto_type = wrappers_pb2.Int64Value _python_type = int class UInt64ValueRule(WrapperRule): _proto_type = wrappers_pb2.UInt64Value _python_type = int class Int32ValueRule(WrapperRule): _proto_type = wrappers_pb2.Int32Value _python_type = int class UInt32ValueRule(WrapperRule): _proto_type = wrappers_pb2.UInt32Value _python_type = int class BoolValueRule(WrapperRule): _proto_type = wrappers_pb2.BoolValue _python_type = bool class StringValueRule(WrapperRule): _proto_type = wrappers_pb2.StringValue _python_type = str class BytesValueRule(WrapperRule): _proto_type = wrappers_pb2.BytesValue _python_type = bytes rules/__init__.py 0000644 00000001077 15030365350 0010014 0 ustar 00 # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. collections/maps.py 0000644 00000005551 15030365350 0010402 0 ustar 00 # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import collections from proto.utils import cached_property from google.protobuf.message import Message class MapComposite(collections.abc.MutableMapping): """A view around a mutable sequence in protocol buffers. This implements the full Python MutableMapping interface, but all methods modify the underlying field container directly. """ @cached_property def _pb_type(self): """Return the protocol buffer type for this sequence.""" # Huzzah, another hack. Still less bad than RepeatedComposite. return type(self.pb.GetEntryClass()().value) def __init__(self, sequence, *, marshal): """Initialize a wrapper around a protobuf map. Args: sequence: A protocol buffers map. marshal (~.MarshalRegistry): An instantiated marshal, used to convert values going to and from this map. """ self._pb = sequence self._marshal = marshal def __contains__(self, key): # Protocol buffers is so permissive that querying for the existence # of a key will in of itself create it. # # By taking a tuple of the keys and querying that, we avoid sending # the lookup to protocol buffers and therefore avoid creating the key. return key in tuple(self.keys()) def __getitem__(self, key): # We handle raising KeyError ourselves, because otherwise protocol # buffers will create the key if it does not exist. if key not in self: raise KeyError(key) return self._marshal.to_python(self._pb_type, self.pb[key]) def __setitem__(self, key, value): pb_value = self._marshal.to_proto(self._pb_type, value, strict=True) # Directly setting a key is not allowed; however, protocol buffers # is so permissive that querying for the existence of a key will in # of itself create it. # # Therefore, we create a key that way (clearing any fields that may # be set) and then merge in our values. self.pb[key].Clear() self.pb[key].MergeFrom(pb_value) def __delitem__(self, key): self.pb.pop(key) def __len__(self): return len(self.pb) def __iter__(self): return iter(self.pb) @property def pb(self): return self._pb collections/__pycache__/repeated.cpython-310.pyc 0000644 00000012573 15030365350 0015574 0 ustar 00 o �h � @ sP d dl Z d dlZd dlmZ d dlmZ G dd� de jj�ZG dd� de�Z dS )� N)�Iterable)�cached_propertyc @ s� e Zd ZdZdd�dd�Zdd� Zdd � Zd d � Zd d � Zdd� Z dd� Z dd� Z dd� Z de fdd�Zddd�ded efd d �Zed d � �ZdS )!�Repeatedz�A view around a mutable sequence in protocol buffers. This implements the full Python MutableSequence interface, but all methods modify the underlying field container directly. N)� proto_typec C s || _ || _|| _dS )a Initialize a wrapper around a protobuf repeated field. Args: sequence: A protocol buffers repeated field. marshal (~.MarshalRegistry): An instantiated marshal, used to convert values going to and from this map. N)�_pb�_marshal� _proto_type)�self�sequence�marshalr � r �U/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/collections/repeated.py�__init__ s zRepeated.__init__c C s t | �| jdd� | jd�S )z%Copy this object and return the copy.N)r )�type�pbr �r r r r �__copy__) s zRepeated.__copy__c C s | j |= dS )zDelete the given item.N�r �r �keyr r r � __delitem__- s zRepeated.__delitem__c C s> t |d�rt| j�t|j�kS t|t�r t| j�t|�kS dS )Nr F)�hasattr�tupler � isinstancer �r �otherr r r �__eq__1 s zRepeated.__eq__c C s | j | S )zReturn the given item.r r r r r � __getitem__6 � zRepeated.__getitem__c C s t | j�S )z"Return the length of the sequence.)�lenr r r r r �__len__: r zRepeated.__len__c C s | |k S �Nr r r r r �__ne__> s zRepeated.__ne__c C s t g | ��S r! )�reprr r r r �__repr__A s zRepeated.__repr__c C s || j |< d S r! r )r r �valuer r r � __setitem__D s zRepeated.__setitem__�indexc C s | j �||� dS �z2Insert ``value`` in the sequence before ``index``.N)r �insert)r r' r% r r r r) G s zRepeated.insertF�r �reverser r+ c C s | j j||d� dS )zStable sort *IN PLACE*.r* N)r �sort)r r r+ r r r r, K s z Repeated.sortc C s | j S r! )r r r r r r O s z Repeated.pb)�__name__� __module__� __qualname__�__doc__r r r r r r r" r$ r& �intr) �str�boolr, �propertyr r r r r r s r c sJ e Zd ZdZedd� �Z� fdd�Zdd� Zdd � Zd e fd d �Z � Z S ) �RepeatedCompositez�A view around a mutable sequence of messages in protocol buffers. This implements the full Python MutableSequence interface, but all methods modify the underlying field container directly. c C sh | j dur| j S t| j�dkrt| jd �S t| jd�r(t| jjd�r(| jjjS t�| j�� � }t|�S )z2Return the protocol buffer type for this sequence.Nr �_message_descriptor�_concrete_class) r r r r r r6 r7 �copy�deepcopy�add)r �canaryr r r �_pb_type[ s � zRepeatedComposite._pb_typec s8 t � �|�rdS t|t�rtdd� | D ��t|�kS dS )NTc S s g | ]}|�qS r r )�.0�ir r r � <listcomp>| s z,RepeatedComposite.__eq__.<locals>.<listcomp>F)�superr r r r r �� __class__r r r x s ���zRepeatedComposite.__eq__c C s | j �| j| j| �S r! )r � to_pythonr< r r r r r r � s z RepeatedComposite.__getitem__c C sh t |t�r*t| � | krt| �k r&n td��| �|� | �||� d S td��t |t�r�|�t| ��\}}}t |tj j �sDt d��|dkr~t |�D ]\}}|| |k r]| �|| � | �|| |� qLt || t|� �D ] }| �|t|� � qpd S t |||�} t|�t| �kr�tdt|�� dt| �� ���t| |�D ]\}}|| |< q�d S t dt|�j� ���)Nz"list assignment index out of rangezcan only assign an iterable� z#attempt to assign sequence of size z to extended slice of size z-list indices must be integers or slices, not )r r1 r �popr) � IndexError�slice�indices� collections�abcr � TypeError� enumerate�range� ValueError�zipr r- ) r r r% �start�stop�stepr' �item�_rH r r r r& � sB � � ��� ��z RepeatedComposite.__setitem__r' c C s" | j �| j|�}| j�||� dS r( )r �to_protor< r r) )r r' r% �pb_valuer r r r) � s zRepeatedComposite.insert) r- r. r/ r0 r r< r r r& r1 r) � __classcell__r r rA r r5 T s 6r5 ) rI r8 �typingr � proto.utilsr rJ �MutableSequencer r5 r r r r �<module> s > collections/__pycache__/__init__.cpython-310.pyc 0000644 00000000514 15030365350 0015532 0 ustar 00 o �h� � @ s, d dl mZ d dlmZ d dlmZ dZdS )� )� MapComposite)�Repeated)�RepeatedComposite)r r r N)�mapsr �repeatedr r �__all__� r r �U/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/collections/__init__.py�<module> s collections/__pycache__/maps.cpython-310.pyc 0000644 00000004673 15030365350 0014745 0 ustar 00 o �hi � @ s8 d dl Z d dlmZ d dlmZ G dd� de jj�ZdS )� N)�cached_property)�Messagec @ s` e Zd ZdZedd� �Zdd� Zdd� Zdd � Zd d � Z d d � Z dd� Z dd� Z e dd� �ZdS )� MapCompositez�A view around a mutable sequence in protocol buffers. This implements the full Python MutableMapping interface, but all methods modify the underlying field container directly. c C s t | j�� � j�S )z2Return the protocol buffer type for this sequence.)�type�pb� GetEntryClass�value��self� r �Q/usr/local/CyberCP/lib/python3.10/site-packages/proto/marshal/collections/maps.py�_pb_type s zMapComposite._pb_typec C s || _ || _dS )z�Initialize a wrapper around a protobuf map. Args: sequence: A protocol buffers map. marshal (~.MarshalRegistry): An instantiated marshal, used to convert values going to and from this map. N)�_pb�_marshal)r �sequence�marshalr r r �__init__" s zMapComposite.__init__c C s |t | �� �v S �N)�tuple�keys�r �keyr r r � __contains__- s zMapComposite.__contains__c C s& || vrt |��| j�| j| j| �S r )�KeyErrorr � to_pythonr r r r r r � __getitem__5 s zMapComposite.__getitem__c C s6 | j j| j|dd�}| j| �� | j| �|� d S )NT)�strict)r �to_protor r �Clear� MergeFrom)r r r �pb_valuer r r � __setitem__< s zMapComposite.__setitem__c C s | j �|� d S r )r �popr r r r � __delitem__G s zMapComposite.__delitem__c C � t | j�S r )�lenr r r r r �__len__J � zMapComposite.__len__c C r$ r )�iterr r r r r �__iter__M r' zMapComposite.__iter__c C s | j S r )r r r r r r P s zMapComposite.pbN)�__name__� __module__� __qualname__�__doc__r r r r r r! r# r& r) �propertyr r r r r r s r )� collections� proto.utilsr �google.protobuf.messager �abc�MutableMappingr r r r r �<module> s collections/repeated.py 0000644 00000015426 15030365350 0011235 0 ustar 00 # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import collections import copy from typing import Iterable from proto.utils import cached_property class Repeated(collections.abc.MutableSequence): """A view around a mutable sequence in protocol buffers. This implements the full Python MutableSequence interface, but all methods modify the underlying field container directly. """ def __init__(self, sequence, *, marshal, proto_type=None): """Initialize a wrapper around a protobuf repeated field. Args: sequence: A protocol buffers repeated field. marshal (~.MarshalRegistry): An instantiated marshal, used to convert values going to and from this map. """ self._pb = sequence self._marshal = marshal self._proto_type = proto_type def __copy__(self): """Copy this object and return the copy.""" return type(self)(self.pb[:], marshal=self._marshal) def __delitem__(self, key): """Delete the given item.""" del self.pb[key] def __eq__(self, other): if hasattr(other, "pb"): return tuple(self.pb) == tuple(other.pb) return tuple(self.pb) == tuple(other) if isinstance(other, Iterable) else False def __getitem__(self, key): """Return the given item.""" return self.pb[key] def __len__(self): """Return the length of the sequence.""" return len(self.pb) def __ne__(self, other): return not self == other def __repr__(self): return repr([*self]) def __setitem__(self, key, value): self.pb[key] = value def insert(self, index: int, value): """Insert ``value`` in the sequence before ``index``.""" self.pb.insert(index, value) def sort(self, *, key: str = None, reverse: bool = False): """Stable sort *IN PLACE*.""" self.pb.sort(key=key, reverse=reverse) @property def pb(self): return self._pb class RepeatedComposite(Repeated): """A view around a mutable sequence of messages in protocol buffers. This implements the full Python MutableSequence interface, but all methods modify the underlying field container directly. """ @cached_property def _pb_type(self): """Return the protocol buffer type for this sequence.""" # Provide the marshal-given proto_type, if any. # Used for RepeatedComposite of Enum. if self._proto_type is not None: return self._proto_type # There is no public-interface mechanism to determine the type # of what should go in the list (and the C implementation seems to # have no exposed mechanism at all). # # If the list has members, use the existing list members to # determine the type. if len(self.pb) > 0: return type(self.pb[0]) # We have no members in the list, so we get the type from the attributes. if hasattr(self.pb, "_message_descriptor") and hasattr( self.pb._message_descriptor, "_concrete_class" ): return self.pb._message_descriptor._concrete_class # Fallback logic in case attributes are not available # In order to get the type, we create a throw-away copy and add a # blank member to it. canary = copy.deepcopy(self.pb).add() return type(canary) def __eq__(self, other): if super().__eq__(other): return True return ( tuple([i for i in self]) == tuple(other) if isinstance(other, Iterable) else False ) def __getitem__(self, key): return self._marshal.to_python(self._pb_type, self.pb[key]) def __setitem__(self, key, value): # The underlying protocol buffer does not define __setitem__, so we # have to implement all the operations on our own. # If ``key`` is an integer, as in list[index] = value: if isinstance(key, int): if -len(self) <= key < len(self): self.pop(key) # Delete the old item. self.insert(key, value) # Insert the new item in its place. else: raise IndexError("list assignment index out of range") # If ``key`` is a slice object, as in list[start:stop:step] = [values]: elif isinstance(key, slice): start, stop, step = key.indices(len(self)) if not isinstance(value, collections.abc.Iterable): raise TypeError("can only assign an iterable") if step == 1: # Is not an extended slice. # Assign all the new values to the sliced part, replacing the # old values, if any, and unconditionally inserting those # values whose indices already exceed the slice length. for index, item in enumerate(value): if start + index < stop: self.pop(start + index) self.insert(start + index, item) # If there are less values than the length of the slice, remove # the remaining elements so that the slice adapts to the # newly provided values. for _ in range(stop - start - len(value)): self.pop(start + len(value)) else: # Is an extended slice. indices = range(start, stop, step) if len(value) != len(indices): # XXX: Use PEP 572 on 3.8+ raise ValueError( f"attempt to assign sequence of size " f"{len(value)} to extended slice of size " f"{len(indices)}" ) # Assign each value to its index, calling this function again # with individual integer indexes that get processed above. for index, item in zip(indices, value): self[index] = item else: raise TypeError( f"list indices must be integers or slices, not {type(key).__name__}" ) def insert(self, index: int, value): """Insert ``value`` in the sequence before ``index``.""" pb_value = self._marshal.to_proto(self._pb_type, value) self.pb.insert(index, pb_value) collections/__init__.py 0000644 00000001363 15030365350 0011176 0 ustar 00 # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from .maps import MapComposite from .repeated import Repeated from .repeated import RepeatedComposite __all__ = ( "MapComposite", "Repeated", "RepeatedComposite", ) compat.py 0000644 00000004455 15030365350 0006411 0 ustar 00 # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # This file pulls in the container types from internal protocol buffers, # and exports the types available. # # If the C extensions were not installed, then their container types will # not be included. from google.protobuf.internal import containers # Import all message types to ensure that pyext types are recognized # when upb types exist. Conda's protobuf defaults to pyext despite upb existing. # See https://github.com/googleapis/proto-plus-python/issues/470 try: from google._upb import _message as _message_upb except ImportError: _message_upb = None try: from google.protobuf.pyext import _message as _message_pyext except ImportError: _message_pyext = None repeated_composite_types = (containers.RepeatedCompositeFieldContainer,) repeated_scalar_types = (containers.RepeatedScalarFieldContainer,) map_composite_types = (containers.MessageMap,) # In `proto/marshal.py`, for compatibility with protobuf 5.x, # we'll use `map_composite_type_names` to check whether # the name of the class of a protobuf type is # `MessageMapContainer`, and, if `True`, return a MapComposite. # See https://github.com/protocolbuffers/protobuf/issues/16596 map_composite_type_names = ("MessageMapContainer",) for message in [_message_upb, _message_pyext]: if message: repeated_composite_types += (message.RepeatedCompositeContainer,) repeated_scalar_types += (message.RepeatedScalarContainer,) try: map_composite_types += (message.MessageMapContainer,) except AttributeError: # The `MessageMapContainer` attribute is not available in Protobuf 5.x+ pass __all__ = ( "repeated_composite_types", "repeated_scalar_types", "map_composite_types", "map_composite_type_names", ) __init__.py 0000644 00000001166 15030365350 0006661 0 ustar 00 # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from .marshal import Marshal __all__ = ("Marshal",)
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings