3
�}:ah= � @ s� d Z ddlZddlZddlZddlmZmZ ddlZddlm Z m
Z
m Z m Z ej
e�ZG dd� d�ZG dd� dej�ZG d d
� d
e je jed �Zeed �d
d�Zd dd�Zdd� Zd!dd�Zdd� Z dd� Z dd� Z d d � Z G d d � 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)�Dict�Type)�b64�errors�
interfaces�utilc @ sr e Zd ZdZd Zd d d
�Zed d � �Zd
d� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
edd� �Zedd � �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.
� json_name�default� omitempty�fdec�fencNFc C s> || _ || _|| _|d kr | jn|| _|d kr4| jn|| _d S )N)r r
r �default_decoderr �default_encoderr
)�selfr r
r �decoder�encoder� r � /usr/lib/python3.6/json_util.py�__init__/ s
zField.__init__c C s 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)�cls�valuer r r �_empty9 s z Field._emptyc C s | j |�o| jS )zOmit the value in output?)r r )r r r r r �omitC s z
Field.omitc K s, | j | j| j| j| jd�|�}t| �f |�S )N)r r
r r r )r r
r r r
�type)r �kwargsZcurrentr r r �_update_paramsG s
zField._update_paramsc C s | j |d�S )z6Descriptor to change the decoder on JSON object field.)r )r )r r r r r r P s z
Field.decoderc C s | j |d�S )z6Descriptor to change the encoder on JSON object field.)r )r )r r
r r r r T s z
Field.encoderc C s
| j |�S )z4Decode a value, optionally with context JSON object.)r )r r r r r �decodeX s z Field.decodec C s
| j |�S )z4Encode a value, optionally with context JSON object.)r
)r r r r r �encode\ s z Field.encodec sN t |t�r t� fdd�|D ��S t |t�rFtj� fdd�|j� D ��S |S dS )z�Default decoder.
Recursively deserialize into immutable types (
:class:`josepy.util.frozendict` instead of
:func:`dict`, :func:`tuple` instead of :func:`list`).
c 3 s | ]}� j |�V qd S )N)r )�.0Zsubvalue)r r r � <genexpr>k s z(Field.default_decoder.<locals>.<genexpr>c s" i | ]\}}� j |�� j |��qS r )r )r! �keyr )r r r �
<dictcomp>n s z)Field.default_decoder.<locals>.<dictcomp>N)r �list�tuple�dictr Z
frozendict�items)r r r )r r r ` s
zField.default_decoderc C s |S )z Default (passthrough) encoder.r )r r r r r r s s zField.default_encoder)r r
r r r
)NFNN)�__name__�
__module__� __qualname__�__doc__� __slots__r � classmethodr r r r r r r r r r r r r r s
r c @ s* e Zd ZU dZi Zeeef dd� 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).
c C s� i }x |D ]}|j t|di �� q
W x0t|j� �D ] \}}t|t�r2|j|�||< q2W |jdf �|d< tt|d �t|j � � �|d< ||d< t
j j | |||�S )N�_fieldsr- Z _orig_slots)
�update�getattrr& r( r r �pop�getr% �keys�abc�ABCMeta�__new__)Zmcs�name�basesZdikt�fields�baser# r r r r r8 � s
z JSONObjectWithFieldsMeta.__new__N) r) r* r+ r, r0 r �strr r8 r r r r r/ { s
&r/ c sn e Zd ZdZeed�dd��Z� fdd�Zdd� Zd d
� Z d d � Z
ed
d� �Z edd� �Z edd� �Z
� ZS )�JSONObjectWithFieldsa� 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'
)�returnc C s dd� | j j� D �S )zGet default fields values.c S s i | ]\}}|j |�qS r )r
)r! �slot�fieldr r r r$ � s z2JSONObjectWithFields._defaults.<locals>.<dictcomp>)r0 r( )r r r r � _defaults� s z JSONObjectWithFields._defaultsc s t � jf | j� |�� d S )N)�superr rB )r r )� __class__r r r � s z JSONObjectWithFields.__init__c C sD y| j | }W n$ tk
r2 tjdj|���Y nX |jt| |��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})r0 �KeyErrorr �Error�formatr r2 )r r9 rA r r r r � s
zJSONObjectWithFields.encodec C s� i }t � }x�| jj� D ]z\}}t| |�}|j|�rB|j||f� qy|j|�||j< W q tj k
r� } ztj dj
|||���W Y dd}~X qX qW |S )zSerialize fields to JSON.z Could not encode {0} ({1}): {2}N) �setr0 r( r2 r �addr r r ZSerializationErrorrG )r �jobjZomittedr@ rA r �errorr r r �fields_to_partial_json� s
"z+JSONObjectWithFields.fields_to_partial_jsonc C s | j � S )N)rL )r r r r �to_partial_json s z$JSONObjectWithFields.to_partial_jsonc C sZ t � }x4| jj� D ]&\}}|j r|j|kr|j|j� qW |rVtjdjdj |����d S )Nz&The following fields are required: {0}�,)
rH r0 r( r r rI r �DeserializationErrorrG �join)r rJ Zmissing�_rA r r r �_check_required s z$JSONObjectWithFields._check_requiredc C s� | j |� i }x�| jj� D ]z\}}|j|kr>|jr>|j||< q||j }y|j|�||< W q tjk
r� } ztjdj |||���W Y dd}~X qX qW |S )z Deserialize fields from JSON.z#Could not decode {0!r} ({1!r}): {2}N)
rR r0 r( r r r
r r rO rG )r rJ r; r@ rA r rK r r r �fields_from_json s
"z%JSONObjectWithFields.fields_from_jsonc C s | f | j |��S )N)rS )r rJ r r r � from_json& s z JSONObjectWithFields.from_json)r) r* r+ r, r. r rB r r rL rM rR rS rT �
__classcell__r r )rD r r> � s r> )� metaclass)�datar? c C s t j| �jd�S )zJEncode JOSE Base-64 field.
:param bytes data:
:rtype: `str`
�ascii)r Z b64encoder )rW r r r �encode_b64jose+ s rY Fc C s� yt j| j� �}W n. tjk
r@ } ztj|��W Y dd}~X nX |dk r|| r\t|�|ksl|r|t|�|k r|tjdj|���|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 b64decoder �binasciirF r rO �lenrG )rW �size�minimumZdecodedrK r r r �decode_b64jose6 s r^ c C s t j| �j� S )z;Hexlify.
:param bytes value:
:rtype: unicode
)rZ Zhexlifyr )r r r r � encode_hex16N s r_ c C s� | j � } |dk rB| r&t| �|d ks:|rBt| �|d k rBtj� �y
tj| �S tjk
rz } ztj|��W Y dd}~X nX 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� )r r[ r rO rZ Z unhexlifyrF )r r\ r] rK r r r � decode_hex16X s
ra c C s t tjjtjj| j��S )z�Encode certificate as JOSE Base-64 DER.
:type cert: `OpenSSL.crypto.X509` wrapped in `.ComparableX509`
:rtype: unicode
)rY �OpenSSL�cryptoZdump_certificate�
FILETYPE_ASN1�wrapped)Zcertr r r � encode_certm s rf c C sR y t jtjjtjjt| ���S tjjk
rL } ztj |��W Y dd}~X nX dS )z�Decode JOSE Base-64 DER-encoded certificate.
:param unicode b64der:
:rtype: `OpenSSL.crypto.X509` wrapped in `.ComparableX509`
N)
r �ComparableX509rb rc Zload_certificaterd r^ rF r rO )�b64derrK r r r � decode_certx s
ri c C s t tjjtjj| j��S )zEncode CSR as JOSE Base-64 DER.
:type csr: `OpenSSL.crypto.X509Req` wrapped in `.ComparableX509`
:rtype: unicode
)rY rb rc Zdump_certificate_requestrd re )Zcsrr r r �
encode_csr� s rj c C sR y t jtjjtjjt| ���S tjjk
rL } ztj |��W Y dd}~X nX dS )z�Decode JOSE Base-64 DER-encoded CSR.
:param unicode b64der:
:rtype: `OpenSSL.crypto.X509Req` wrapped in `.ComparableX509`
N)
r rg rb rc Zload_certificate_requestrd r^ rF r rO )rh rK r r r �
decode_csr� s
rk c @ s` e Zd ZU dZeZedZeeZe ee
f e d dd��Z e dd� �Z
dd � Ze d
d � �ZdS )
�TypedJSONObjectWithFieldszJSON object with type.r Nc C s |dkr|j n|}|| j|< |S )z(Register class for JSON deserialization.N)�typ�TYPES)r �type_clsrm r r r �register� s
z"TypedJSONObjectWithFields.registerc C s� | | j j� kr.| j|kr*tjdj| j���| S t|t�sHtjdj|���y|| j }W n tk
rt tjd��Y nX y
| j | S tk
r� tj ||��Y nX dS )z&Get the registered class for ``jobj``.zMissing type field ({0})z {0} is not a dictionary objectzmissing type fieldN)
rn �values�type_field_namer rO rG r r' rE ZUnrecognizedTypeError)r rJ rm r r r � get_type_cls� s
z&TypedJSONObjectWithFields.get_type_clsc C s | j � }| 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
)rL rm rr )r rJ r r r rM � s z)TypedJSONObjectWithFields.to_partial_jsonc C s | j |�}|f |j|��S )z�Deserialize ACME object from valid JSON object.
:raises josepy.errors.UnrecognizedTypeError: if type
of the ACME object has not been registered.
)rs rS )r rJ ro r r r rT � s
z#TypedJSONObjectWithFields.from_json)N)r) r* r+ r, �NotImplementedrm r= rr rn r r r. rp rs rM rT r r r r rl � s
rl )NF)NF)!r, r6 rZ ZloggingZtypingr r rb Zjosepyr r r r Z getLoggerr) Zloggerr r7 r/ Z ImmutableMapZJSONDeSerializabler> �bytesr= rY r^ r_ ra rf ri rj rk rl r r r r �<module> s*
f>p