⚝
One Hat Cyber Team
⚝
Your IP:
216.73.216.144
Server IP:
157.245.143.252
Server:
Linux www 6.11.0-9-generic #9-Ubuntu SMP PREEMPT_DYNAMIC Mon Oct 14 13:19:59 UTC 2024 x86_64
Server Software:
nginx/1.26.0
PHP Version:
8.3.11
Buat File
|
Buat Folder
Eksekusi
Dir :
~
/
lib
/
python3
/
dist-packages
/
josepy
/
__pycache__
/
View File Name :
interfaces.cpython-312.pyc
en d Z ddlZddlZddlmZmZ ddlmZmZm Z m Z ddl m Z e dd Z G d dej Zy) zJOSE interfaces. N)MappingSequence)AnyTypeTypeVarUnion)errorsGenericJSONDeSerializableJSONDeSerializable)boundc e Zd ZdZej defd ZdefdZe ej de e dede fd Z e de e de eef de fd Zd edefd Zdefd Ze d d defd Zy)r a 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() returnc t )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. )NotImplementedErrorselfs 3/usr/lib/python3/dist-packages/josepy/interfaces.pyto_partial_jsonz"JSONDeSerializable.to_partial_jsonc s " "## c 8 dt dt ffd | 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. objr c t | t r | j S t | t r| S t | t r| D cg c] } | c}S t | t rt fd| D S t | t r0| j D ci c] \ }} | | c}}S | S c c}w c c}}w )Nc 3 . K | ] } | y w)N ).0subobj _serializes r <genexpr>zAJSONDeSerializable.to_json.<locals>._serialize.<locals>.<genexpr> s BcFZ /cs ) isinstancer r strlistr tupler items)r r keyvaluer s r r z.JSONDeSerializable.to_json.<locals>._serialize s # 12!#"5"5"788#s# C&9<=v 6*==C* Bc BBBC)MPYY[Y[zsE 3E)::[YY > Zs C'C )r )r r s @r to_jsonzJSONDeSerializable.to_jsonv s# C C $ r clsjobjc | 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 )r' r( s r from_jsonz JSONDeSerializable.from_json s " u r json_stringc t j | }| j | S # t $ r}t j | d}~ww xY w)z&Deserialize from JSON document string.N)jsonloads ValueErrorr DeserializationErrorr* )r' r+ r. errors r json_loadsz JSONDeSerializable.json_loads sI 5JJ{+E }}U## 5--e4 4 5s ( A AA kwargsc F t j | fd| j i|S )zsDump to JSON string using proper serializer. :returns: JSON document string. :rtype: str default)r- dumpsjson_dump_default)r r3 s r json_dumpsz JSONDeSerializable.json_dumps s# zz$I(>(>I&IIr c * | j ddd S )zNDump the object to pretty JSON document string. :rtype: str T ),z: ) sort_keysindent separators)r8 r s r json_dumps_prettyz$JSONDeSerializable.json_dumps_pretty s aKPPr python_objectc p t |t r|j S t t | dz )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 serializable)r r r TypeErrorrepr)r' r@ s r r7 z$JSONDeSerializable.json_dump_default s4 m%7 8 002 2D /2M MN Nr N)__name__ __module__ __qualname____doc__abcabstractmethodr r r& classmethodr r r* r r bytesr2 r8 r? r7 r r r r r s Tl $ $ $$ @ t 56 c F_ " $ + ,$;@e;L$ "$ $J3 J3 JQ3 Q O.B Os O Or ) metaclass)rG rH r- collections.abcr r typingr r r r josepyr r ABCMetar r r r <module>rQ s= - , , #$?G[ \ JO3;; JOr