Current File : //proc/self/root/lib/python3.6/site-packages/josepy/__pycache__/interfaces.cpython-36.pyc

3

�}:a�@sNdZd
dl
Z
d
dlZd
dlmZmZ
d
dlmZmZ
Gdd�de	e
j
d�ZdS)zJOSE interfaces.�N)�errors�util)�Sequence�Mappingc@s\eZ
dZd
Zejdd��
Zdd�Zej	dd��
Z
edd	��
Zd
d�Z
dd
�Zedd��
ZdS)�JSONDeSerializablea�Interface for (de)serializable JSON objects.

    Please recall, that standard Python library implements
    :class:`json.JSONEncoder` and :class:`json.JSONDecoder` that perform
    translations based on respective :ref:`conversion tables
    <conversion-table>` that look pretty much like the one below (for
    complete tables see relevant Python documentation):

    .. _conversion-table:

    ======  ======
     JSON   Python
    ======  ======
    object  dict
    ...     ...
    ======  ======

    While the above **conversion table** is about translation of JSON
    documents to/from the basic Python types only,
    :class:`JSONDeSerializable` introduces the following two concepts:

      serialization
        Turning an arbitrary Python object into Python object that can
        be encoded into a JSON document. **Full serialization** produces
        a Python object composed of only basic types as required by the
        :ref:`conversion table <conversion-table>`. **Partial
        serialization** (accomplished by :meth:`to_partial_json`)
        produces a Python object that might also be built from other
        :class:`JSONDeSerializable` objects.

      deserialization
        Turning a decoded Python object (necessarily one of the basic
        types as required by the :ref:`conversion table
        <conversion-table>`) into an arbitrary Python object.

    Serialization produces **serialized object** ("partially serialized
    object" or "fully serialized object" for partial and full
    serialization respectively) and deserialization produces
    **deserialized object**, both usually denoted in the source code as
    ``jobj``.

    Wording in the official Python documentation might be confusing
    after reading the above, but in the light of those definitions, one
    can view :meth:`json.JSONDecoder.decode` as decoder and
    deserializer of basic types, :meth:`json.JSONEncoder.default` as
    serializer of basic types, :meth:`json.JSONEncoder.encode`  as
    serializer and encoder of basic types.

    One could extend :mod:`json` to support arbitrary object
    (de)serialization either by:

      - overriding :meth:`json.JSONDecoder.decode` and
        :meth:`json.JSONEncoder.default` in subclasses

      - or passing ``object_hook`` argument (or ``object_hook_pairs``)
        to :func:`json.load`/:func:`json.loads` or ``default`` argument
        for :func:`json.dump`/:func:`json.dumps`.

    Interestingly, ``default`` is required to perform only partial
    serialization, as :func:`json.dumps` applies ``default``
    recursively. This is the idea behind making :meth:`to_partial_json`
    produce only partial serialization, while providing custom
    :meth:`json_dumps` that dumps with ``default`` set to
    :meth:`json_dump_default`.

    To make further documentation a bit more concrete, please, consider
    the following imaginatory implementation example::

      class Foo(JSONDeSerializable):
          def to_partial_json(self):
              return 'foo'

          @classmethod
          def from_json(cls, jobj):
              return Foo()

      class Bar(JSONDeSerializable):
          def to_partial_json(self):
              return [Foo(), Foo()]

          @classmethod
          def from_json(cls, jobj):
              return Bar()

    c


Cs
t��
d
S)a�
Partially serialize.

        Following the example, **partial serialization** means the following::

          assert isinstance(Bar().to_partial_json()[0], Foo)
          assert isinstance(Bar().to_partial_json()[1], Foo)

          # in particular...
          assert Bar().to_partial_json() != ['foo', 'foo']

        :raises josepy.errors.SerializationError:
            in case of any serialization error.
        :returns: Partially serializable object.

        N)
�NotImplementedError)
�self�r	� /usr/lib/python3.6/interfaces.py�to_partial_jsonfsz"JSONDeSerializable.to_partial_jsonc

s�f
d
d���|�
S)aD
Fully serialize.

        Again, following the example from before, **full serialization**
        means the following::

          assert Bar().to_json() == ['foo', 'foo']

        :raises josepy.errors.SerializationError:
            in case of any serialization error.
        :returns: Fully serialized object.

        c

s�t|t
�r�|j��
St|t�r$|St|t�r@�f
d
d�|D�
St|t�r`t�f
dd�|D�
�
St|t�r��f
dd�|j�D�
S|SdS)Nc
sg|]}
�|
�
�qSr	r	)�.0�subobj)
�
_serializer	r
�
<listcomp>�szBJSONDeSerializable.to_json.<locals>._serialize.<locals>.<listcomp>c
3s|]}
�|
�
V
qdS)
Nr	)rr
)
rr	r
�	<genexpr>�szAJSONDeSerializable.to_json.<locals>._serialize.<locals>.<genexpr>c
si|]\}
}�|�
�|
�
�qSr	r	)r�key�value)
rr	r
�
<dictcomp>�s
zBJSONDeSerializable.to_json.<locals>._serialize.<locals>.<dictcomp>)	�
isinstancerr�str�listr�tupler�items)
�obj)
rr	r
r�s















z.JSONDeSerializable.to_json.<locals>._serializer	)
rr	)
rr
�to_jsonys
zJSONDeSerializable.to_jsonc
Cs|�S)
a�
Deserialize a decoded JSON document.

        :param jobj: Python object, composed of only other basic data
            types, as decoded from JSON document. Not necessarily
            :class:`dict` (as decoded from "JSON object" document).

        :raises josepy.errors.DeserializationError:
            if decoding was unsuccessful, e.g. in case of unparseable
            X509 certificate, or wrong padding in JOSE base64 encoded
            string, etc.

        r	)�clsZjobjr	r	r
�	from_json�szJSONDeSerializable.from_jsoncCsFytj
|
�
}Wn,tk
r:
}
ztj|�
�
WYd
d
}~XnX|j|�
S)z&Deserialize from JSON document string.N)�json�loads�
ValueErrorrZDeserializationErrorr)rZjson_stringr�errorr	r	r
�
json_loads�s




zJSONDeSerializable.json_loadsc
Kstj
|f
d
|ji
|
��
S)zsDump to JSON string using proper serializer.

        :returns: JSON document string.
        :rtype: str

        �default)r�dumps�json_dump_default)r�kwargsr	r	r
�
json_dumps�szJSONDeSerializable.json_dumpsc

Cs|jd
ddd�S)zNDump the object to pretty JSON document string.

        :rtype: str

        T��
,�: )Z	sort_keys�indentZ
separators)r(r))
r&)
rr	r	r
�json_dumps_pretty�sz$JSONDeSerializable.json_dumps_prettycCs&t|
t
�r|
j�Stt|
�
d
�
�
dS)a�
Serialize Python object.

        This function is meant to be passed as ``default`` to
        :func:`json.dump` or :func:`json.dumps`. They call
        ``default(python_object)`` only for non-basic Python types, so
        this function necessarily raises :class:`TypeError` if
        ``python_object`` is not an instance of
        :class:`IJSONSerializable`.

        Please read the class docstring for more information.

        z is not JSON serializableN)rrr�	TypeError�repr)rZ
python_objectr	r	r
r$�s

z$JSONDeSerializable.json_dump_defaultN)�__name__�
__module__�__qualname__�__doc__�abc�abstractmethodrrr�abstractclassmethodr�classmethodr!r&r+r$r	r	r	r
rsV 		r)
�	metaclass)r1r2rZjosepyrr�collections.abcrr�object�ABCMetarr	r	r	r
�<module>
s