3

�}:ah=�@s�dZd
dl
Z
d
dlZd
dlZd
dlmZmZ
d
dlZd
dlm	Z	m
Z
mZmZ
ej
e�
ZGdd�d�ZGdd�de
j�ZGd	d
�d
ejejed�Zeed�d
d�Zd dd�
Zdd�Zd!dd�
Zdd�Zdd�Zdd�Zdd�ZGdd�de�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@sreZ
dZd
ZdZdd	d
�
Zedd��
Zd
d�Zdd�Z	dd�Z
dd�Zdd�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�fencNFcCs>|
|_||_
||_|dkr |jn||_|dkr4|jn||_dS)
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__cCst|
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�valuerrr�_empty9szField._emptycCs|j|
�
o|j
S)
zOmit the value in output?)rr)rrrrr�omitCsz
Field.omitc
Ks,|j|j
|j|j|jd
�|
�}t|�
f|�
S)N)r	r
rrr)r	r
rrr
�type)r�kwargsZcurrentrrr�_update_paramsGs



zField._update_paramscCs|j|
d
�
S)z6Descriptor to change the decoder on JSON object field.)
r)
r)rrrrrrPsz
Field.decodercCs|j|
d
�
S)z6Descriptor to change the encoder on JSON object field.)
r)
r)rr
rrrrTsz
Field.encodercCs
|j|
�
S)
z4Decode a value, optionally with context JSON object.)
r)rrrrr�decodeXszField.decodecCs
|j|
�
S)
z4Encode a value, optionally with context JSON object.)
r
)rrrrr�encode\szField.encodecsNt|
t
�r t�f
d
d�|
D�
�
St|
t�rFtj�f
dd�|
j�D�
�
S|
SdS)z�Default decoder.

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

        c
3s|]}
�j|
�
V
qdS)
N)
r)�.0Zsubvalue)
rrr�	<genexpr>ksz(Field.default_decoder.<locals>.<genexpr>c
s"i|]\}
}�j|�
�j|
�
�qSr)
r)r!�keyr)
rrr�
<dictcomp>ns
z)Field.default_decoder.<locals>.<dictcomp>N)r�list�tuple�dictrZ
frozendict�items)rrr)
rrr`s








zField.default_decoderc
Cs|
S)
zDefault (passthrough) encoder.r)rrrrrrsszField.default_encoder)r	r
rrr
)NFNN)�__name__�
__module__�__qualname__�__doc__�	__slots__r�classmethodrrrrrrr rrrrrrrs


	
	rc@s*eZ
dZUd
ZiZeeefdd�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).

    cCs�i}x|D]}|jt
|d
i��

q
Wx0t|j��
D] \}}t|t�r2|j|�
||<q2W|jdf�|d<tt|d�
t|j	��
�
|d<||d
<t
jj||
||�S)N�_fieldsr-Z_orig_slots)
�update�getattrr&r(rr�pop�getr%�keys�abc�ABCMeta�__new__)Zmcs�name�basesZdikt�fields�baser#rrrrr8�s








z JSONObjectWithFieldsMeta.__new__N)	r)r*r+r,r0r�strrr8rrrrr/{s
&r/csneZ
dZd
Zeed�
dd��
Z�f
dd�Zdd�Zd	d
�Z	dd�Z
ed
d��
Zedd��
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

Csd
d�|jj
�D�
S)zGet default fields values.c
Ssi|]\}
}|j|
�qSr)
r
)r!�slot�fieldrrrr$�s
z2JSONObjectWithFields._defaults.<locals>.<dictcomp>)r0r()
rrrr�	_defaults�s
zJSONObjectWithFields._defaultsc
st�j
f|j�|
��

dS)
N)�superrrB)rr)
�	__class__rrr�s
zJSONObjectWithFields.__init__cCsDy|j|
}Wn$t
k
r2


tjd
j|
�
�
�
YnX|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)rr9rArrrr �s
	


zJSONObjectWithFields.encodec
Cs�i}
t�}x�|j
j�D]z\}}t||�}|j|�
rB|j||f�

qy|j|�
|
|j<Wqtj	k
r�
}
ztj	d
j
|||��
�
WYdd}~XqXqW|
S)zSerialize fields to JSON.zCould not encode {0} ({1}): {2}N)�setr0r(r2r�addr r	rZSerializationErrorrG)r�jobjZomittedr@rAr�errorrrr�fields_to_partial_json�s










"
z+JSONObjectWithFields.fields_to_partial_jsonc


Cs|j�S)
N)
rL)
rrrr�to_partial_json
s
z$JSONObjectWithFields.to_partial_jsoncCsZt�}x4|j
j�D]&\}}|jr|j|
kr|j|j�

qW|rVtjd
jdj	|�
�
�
�
dS)Nz&The following fields are required: {0}�
,)
rHr0r(rr	rIr�DeserializationErrorrG�join)rrJZmissing�
_rArrr�_check_required
s





z$JSONObjectWithFields._check_requiredcCs�|j|
�

i}x�|j
j�D]z\}}|j|
kr>|jr>|j||<q|
|j}y|j|�
||<Wqtjk
r�
}
ztjd
j	|||��
�
WYdd}~XqXqW|S)zDeserialize fields from JSON.z#Could not decode {0!r} ({1!r}): {2}N)
rRr0r(r	rr
rrrOrG)rrJr;r@rArrKrrr�fields_from_json
s











"
z%JSONObjectWithFields.fields_from_jsoncCs|f|j|
�
�
S)
N)
rS)rrJrrr�	from_json&
szJSONObjectWithFields.from_json)r)r*r+r,r.rrBrr rLrMrRrSrT�
__classcell__rr)
rDrr>�s
r>)
�	metaclass)�datar?c

Cstj
|�
jd
�
S)zJEncode JOSE Base-64 field.

    :param bytes data:
    :rtype: `str`

    �ascii)rZ	b64encoder)
rWrrr�encode_b64jose+
srYFcCs�ytj
|j��
}Wn.tjk
r@
}
ztj|�
�
WYd
d
}~XnX|
d
k	r||r\t|�
|
ksl|r|t|�
|
kr|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)	rZ	b64decoder �binasciirFrrO�lenrG)rW�size�minimumZdecodedrKrrr�decode_b64jose6
s





r^c

Cstj
|�
j�S)
z;Hexlify.

    :param bytes value:
    :rtype: unicode

    )rZZhexlifyr)
rrrr�encode_hex16N
sr_cCs�|j�}|
d
k	rB|r&t
|�
|
dks:|rBt
|�
|
dkrBtj��
y
tj|�
Stjk
rz
}
ztj|�
�
WYd
d
}~XnXd
S)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[rrOrZZ	unhexlifyrF)rr\r]rKrrr�decode_hex16X
s







rac

Cstt
jjt
jj|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)
Zcertrrr�encode_certm
s
rfc
CsRytj
tjjtjjt|�
��
Stjjk
rL
}

ztj	|
�
�
WYd
d
}
~
XnXd
S)z�Decode JOSE Base-64 DER-encoded certificate.

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

    N)
r�ComparableX509rbrcZload_certificaterdr^rFrrO)�b64derrKrrr�decode_certx
s





ric

Cstt
jjt
jj|j��
S)
zEncode CSR as JOSE Base-64 DER.

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

    )rYrbrcZdump_certificate_requestrdre)
Zcsrrrr�
encode_csr�
s
rjc
CsRytj
tjjtjjt|�
��
Stjjk
rL
}

ztj	|
�
�
WYd
d
}
~
XnXd
S)z�Decode JOSE Base-64 DER-encoded CSR.

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

    N)
rrgrbrcZload_certificate_requestrdr^rFrrO)rhrKrrr�
decode_csr�
s





rkc@s`eZ
dZUd
ZeZedZeeZe	ee
feddd�
�
Zedd��
Z
dd	�Zed
d��
ZdS)
�TypedJSONObjectWithFieldszJSON object with type.rNcCs |d
kr|
jn|}|
|j
|<|
S)z(Register class for JSON deserialization.N)�typ�TYPES)r�type_clsrmrrr�register�
s


z"TypedJSONObjectWithFields.registercCs�||jj
�kr.|j|
kr*tjd
j|j�
�
�
|St|
t�sHtjdj|
�
�
�
y|
|j}Wntk
rt


tjd�
�
YnXy
|j|Stk
r�


tj	||
��
YnXdS)z&Get the registered class for ``jobj``.zMissing type field ({0})z{0} is not a dictionary objectzmissing type fieldN)
rn�values�type_field_namerrOrGrr'rEZUnrecognizedTypeError)rrJrmrrr�get_type_cls�
s 














z&TypedJSONObjectWithFields.get_type_clsc
Cs|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

        )rLrmrr)rrJrrrrM�
s	

z)TypedJSONObjectWithFields.to_partial_jsoncCs|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.

        )rsrS)rrJrorrrrT�
s	

z#TypedJSONObjectWithFields.from_json)
N)r)r*r+r,�NotImplementedrmr=rrrnrrr.rprsrMrTrrrrrl�
s



rl)NF)NF)!r,r6rZZloggingZtypingrrrbZjosepyrrrrZ	getLoggerr)Zloggerrr7r/ZImmutableMapZJSONDeSerializabler>�bytesr=rYr^r_rarfrirjrkrlrrrr�<module>s*




f>

p