a
BgtH @ s d Z ddlZddlZddlZddlmZmZmZmZm Z m
Z
m Z m Z m
Z
ddlmZ ddlmZmZmZmZ eeZd/eeee eegef e eegef eddd ZG d
d d ZG d d
d
eZ G dd dej Z e
dddZ G dd dej ej!e dZ"e#edddZ$d0ee e% ee#dddZ&e#edd d Z'd1ee e% ee#d d d Z(ej)ed!d"d#Z*eej)d$d%d&Z+ej)ed'd(d)Z,eej)d$d*d+Z-e
d,d-dZ.G d.d- d-e"Z/dS )2zJSON (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) AnyCallableDictIterableListMappingOptionalTypeTypeVar)crypto)b64errors
interfacesutilF json_namedefault omitemptydecoderencoderreturnc C s t | ||||dS )a4 Convenient 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
r r r r r ) _TypedFieldr r 4/usr/lib/python3.9/site-packages/josepy/json_util.pyfield s
r c @ s e Zd ZdZdZd eeeee egef ee egef ddddZ
e eedd d
Z eedd d Z
ed d
ddZe egef d dddZe egef d dddZeedddZeedddZe eedddZe eedd d 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.
)r r r fdecfencNFr c C s> || _ || _|| _|d u r | jn|| _|d u r4| jn|| _d S N)r r r default_decoderr default_encoderr )selfr r r r r r r r __init__R s
zField.__init__valuer c C s t |t o| S )zIs 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.
)
isinstanceboolclsr% r r r _emptya s z Field._emptyc C s | |o| jS )zOmit the value in output?)r* r r" r% r r r omitk s z
Field.omitkwargsr c K s0 | j | j| j| j| jd|}t| f i |S )Nr )r r r r r type)r" r. currentr r r _update_paramso s zField._update_params)r r c C s | j |dS )z6Descriptor to change the decoder on JSON object field.)r r1 )r" r r r r r z s z
Field.decoder)r r c C s | j |dS )z6Descriptor to change the encoder on JSON object field.)r r2 )r" r r r r r ~ s z
Field.encoderc C s
| |S )z4Decode a value, optionally with context JSON object.)r r+ r r r decode s z Field.decodec C s
| |S )z4Encode a value, optionally with context JSON object.)r r+ r r r encode s z Field.encodec sN t |tr t fdd|D S t |trFt fdd| D S |S dS )zDefault decoder.
Recursively deserialize into immutable types (
:class:`josepy.util.frozendict` instead of
:func:`dict`, :func:`tuple` instead of :func:`list`).
c 3 s | ]} |V qd S r r ).0Zsubvaluer) r r z(Field.default_decoder..c s" i | ]\}} | |qS r r5 )r6 keyr% r7 r r
s z)Field.default_decoder..N)r& listtupledictr Z
frozendictitemsr( r r7 r r s
zField.default_decoderc C s |S )z Default (passthrough) encoder.r r( r r r r! s zField.default_encoder)NFNN)__name__
__module__ __qualname____doc__ __slots__strr r' r r r# classmethodr* r, r1 r r r3 r4 r r! r r r r r 7 s4 r c @ s e Zd ZdZdS )r a Specialized 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)r@ rA rB rC r r r r r s r c @ sR e Zd ZU dZi Zeeef ed< e e ed< ee
e eee f d dddZ dS )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 _orig_slots)namebases namespacer c C s i }|D ]}| t|di q| D ]P\}}t|tr,t|trn||di vrntd| d| d| |||< q,|dd|d< t
t |d t | |d< ||d< t
j| |||S ) NrH __annotations__zField `z` in JSONObject `z` has no type annotation.rD r rI )updategetattrcopyr? r& r r get
ValueErrorpopr= r< keysabcABCMeta__new__)ZmcsrJ rK rL fieldsbaser: r% r r r rW s
z JSONObjectWithFieldsMeta.__new__N)
r@ rA rB rC rH r rE r rM r r r rW r r r r rG s
' rG GenericJSONObjectWithFieldsJSONObjectWithFields)boundc s e Zd ZdZeeeef dddZedd fdd Z eed d
d Z
eeef dd d
Z eeef dddZ ee
eef ddddZee
eef edddZeee e
eef edddZ ZS )r[ a 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'
r c C s dd | j D S )zGet default fields values.c S s i | ]\}}||j qS r )r )r6 slotr r r r r; r9 z2JSONObjectWithFields._defaults..)rH r? r7 r r r _defaults s z JSONObjectWithFields._defaultsNr- c s" t jf i i | | d S r )superr# r_ )r" r. __class__r r r# s z JSONObjectWithFields.__init__)rJ r c C sB z| j | }W n" ty0 td|Y n0 |t| |S )zEncode 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})rH KeyErrorr
Errorformatr4 rO )r" rJ r r r r r4 s
zJSONObjectWithFields.encodec C s i }t }| j D ]|\}}t| |}||r@|||f qz||||j< W q tj y } z t d
|||W Y d}~qd}~0 0 q|S )zSerialize fields to JSON.z Could not encode {0} ({1}): {2}N) setrH r? rO r, addr4 r r
ZSerializationErrorre )r" jobjZomittedr^ r r% errorr r r fields_to_partial_json/ s
z+JSONObjectWithFields.fields_to_partial_jsonc C s | S r )rj )r" r r r to_partial_jsonA s z$JSONObjectWithFields.to_partial_jsonrh r c C sT t }| j D ]$\}}|js|j|vr||j q|rPtdd |d S )Nz&The following fields are required: {0},)
rf rH r? r r rg r
DeserializationErrorre join)r) rh missing_r r r r _check_requiredD s z$JSONObjectWithFields._check_requiredc C s | | i }| j D ]|\}}|j|vr<|jr<|j||< q||j }z||||< W q tjy } z td |||W Y d}~qd}~0 0 q|S )z Deserialize fields from JSON.z#Could not decode {0!r} ({1!r}): {2}N)
rr rH r? r r r r3 r
rn re )r) rh rX r^ r r% ri r r r fields_from_jsonP s
z%JSONObjectWithFields.fields_from_json)r) rh r c C s | f i | |S r )rs )r) rh r r r from_jsonb s z JSONObjectWithFields.from_json)r@ rA rB rC rF r rE r r_ r# r4 rj rk r rr rs r rZ rt
__classcell__r r ra r r[ s ) metaclass)datar c C s t | dS )zJEncode JOSE Base-64 field.
:param bytes data:
:rtype: `str`
ascii)r Z b64encoder3 )rw r r r encode_b64josei s ry )rw sizeminimumr c
C s zt | }W n0 tjyB } zt|W Y d}~n
d}~0 0 |dur||s\t||ksl|r|t||k r|td||S )a Decode 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 Z b64decoder4 binasciird r
rn lenre )rw rz r{ Zdecodedri r r r decode_b64joset s
r~ r$ c C s t | S )z;Hexlify.
:param bytes value:
:rtype: unicode
)r| Zhexlifyr3 )r% r r r encode_hex16 s r )r% rz r{ r c
C s | }|dur@|s$t||d ks8|r@t||d k r@t z t|W S tjy| } zt|W Y d}~n
d}~0 0 dS )a Decode 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 )r4 r} r
rn r| Z unhexlifyrd )r% rz r{ Zvalue_bri r r r decode_hex16 s r )certr c C s* t | jtjrtdtttj| jS )zEncode 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 ZX509ReqrR ry Zdump_certificate
FILETYPE_ASN1)r r r r encode_cert s r )b64derr c
C sP zt ttjt| W S tjyJ } zt|W Y d}~n
d}~0 0 dS )zDecode JOSE Base-64 DER-encoded certificate.
:param unicode b64der:
:rtype: `OpenSSL.crypto.X509` wrapped in `.ComparableX509`
N) r ComparableX509r Zload_certificater r~ rd r
rn r ri r r r decode_cert s r )csrr c C s* t | jtjrtdtttj| jS )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 ZX509rR ry Zdump_certificate_requestr )r r r r
encode_csr s r c
C sP zt ttjt| W S tjyJ } zt|W Y d}~n
d}~0 0 dS )zDecode JOSE Base-64 DER-encoded CSR.
:param unicode b64der:
:rtype: `OpenSSL.crypto.X509Req` wrapped in `.ComparableX509`
N) r r r Zload_certificate_requestr r~ rd r
rn r r r r
decode_csr s r GenericTypedJSONObjectWithFieldsTypedJSONObjectWithFieldsc @ s e Zd ZU dZeZeed< dZeed< eZ e
ee f ed< e de e
ee e e
ddd Ze eeef e d d
d d Ze
eef d
ddZe eeef d d
ddZdS )r zJSON object with type.typr/ type_field_nameTYPESN)type_clsr r c C s |du r|j n|}|| j|< |S )z(Register class for JSON deserialization.N)r r )r) r r r r r register s
z"TypedJSONObjectWithFields.registerrl c C s | | j v r.| j|vr*td| j| S t|tsHtd|z|| j }W n tyr tdY n0 z | j | W S ty t ||Y n0 dS )z&Get the registered class for ``jobj``.zMissing type field ({0})z {0} is not a dictionary objectzmissing type fieldN)
r valuesr r
rn re r& r> rc ZUnrecognizedTypeError)r) rh r r r r get_type_cls s
z&TypedJSONObjectWithFields.get_type_clsr] c C s | }| j|| j< |S )a Get 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
)rj r r )r" rh r r r rk s z)TypedJSONObjectWithFields.to_partial_jsonc C s | |}|f i ||S )zDeserialize ACME object from valid JSON object.
:raises josepy.errors.UnrecognizedTypeError: if type
of the ACME object has not been registered.
)r rs )r) rh r r r r rt ( s
z#TypedJSONObjectWithFields.from_json)N)r@ rA rB rC NotImplementedr rE rM r r r r rF r r r r r r rk rt r r r r r s
)NFNN)NF)NF)0rC rU r| Zloggingtypingr r r r r r r r r
ZOpenSSLr Zjosepyr r
r r Z getLoggerr@ loggerrE r' r r r rV rG rZ Z ImmutableMapZJSONDeSerializabler[ bytesry intr~ r r r r r r r r r r r r r sL ,
q F
o