serializer.cpython-310.pyc // MEDIA VIEWER

Format: application/x-python-code
⬇ Download File (11.4 KB)
   1  o
   2  
   3  .'h�<�@s�ddlmZddlmZddlZddlZddlm	Z	ddl
   4  mZddl
   5  mZddl
   6  mZddl
   7  mZejrLddlZejd	ejeefejeefd
   8  �Znejd	ejeefd�ZGdd
   9  �d
  10  eje�Zddd�ZGdd�deje�ZdS)�)�annotationsN�)�
  11  want_bytes)�
  12  BadPayload)�BadSignature)�_make_keys_list)�Signer�_TSerialized)�bound�default)r
  13  c@s eZdZddd�Zddd	�Zd
  14  S)
  15  �_PDataSerializer�payloadr	�return�t.AnycC�dS�N�)�selfr
  16  rr�MC:\Users\shubh\Videos\agent\nova\Lib\site-packages\itsdangerous/serializer.py�loads�z_PDataSerializer.loads�objcCrrr�rrrrr�dumpsrz_PDataSerializer.dumpsN)r
  17  r	rr)rrrr	)�__name__�
  18  __module__�__qualname__rrrrrrrs
  19  r�
  20  serializer�_PDataSerializer[t.Any]r�#te.TypeGuard[_PDataSerializer[str]]cCst|�i�t�S)z5Checks whether a serializer generates text or binary.)�
  21  isinstancer�str)rrrr�is_text_serializer#sr"c@s|eZdZUdZeZded<eZded<gZ	ded<e
  22  j											dNdOdd��Ze
  23  j								dPdQdd��Ze
  24  j	dRd	d	d	d	d�dQdd��Ze
  25  j								dPdSd!d��Ze
  26  j	dRd	d	d	d	d�dSd"d��Z											dNdTd$d�Ze
  27  dUd'd(��Z		dVdWd+d,�ZdXd.d/�ZdVdYd1d2�ZdVdZd4d5�ZdVd[d7d8�ZdVd\d<d=�Z		dVd]dAdB�ZdVd^dCdD�Z		dVd_dFdG�Z				d`dadJdK�Z		dVdbdLdM�Zd	S)c�
  28  Serializera:	A serializer wraps a :class:`~itsdangerous.signer.Signer` to
  29      enable serializing and securely signing data other than bytes. It
  30      can unsign to verify that the data hasn't been changed.
  31  
  32      The serializer provides :meth:`dumps` and :meth:`loads`, similar to
  33      :mod:`json`, and by default uses :mod:`json` internally to serialize
  34      the data to bytes.
  35  
  36      The secret key should be a random string of ``bytes`` and should not
  37      be saved to code or version control. Different salts should be used
  38      to distinguish signing in different contexts. See :doc:`/concepts`
  39      for information about the security of the secret key and salt.
  40  
  41      :param secret_key: The secret key to sign and verify with. Can be a
  42          list of keys, oldest to newest, to support key rotation.
  43      :param salt: Extra key to combine with ``secret_key`` to distinguish
  44          signatures in different contexts.
  45      :param serializer: An object that provides ``dumps`` and ``loads``
  46          methods for serializing data to a string. Defaults to
  47          :attr:`default_serializer`, which defaults to :mod:`json`.
  48      :param serializer_kwargs: Keyword arguments to pass when calling
  49          ``serializer.dumps``.
  50      :param signer: A ``Signer`` class to instantiate when signing data.
  51          Defaults to :attr:`default_signer`, which defaults to
  52          :class:`~itsdangerous.signer.Signer`.
  53      :param signer_kwargs: Keyword arguments to pass when instantiating
  54          the ``Signer`` class.
  55      :param fallback_signers: List of signer parameters to try when
  56          unsigning with the default signer fails. Each item can be a dict
  57          of ``signer_kwargs``, a ``Signer`` class, or a tuple of
  58          ``(signer, signer_kwargs)``. Defaults to
  59          :attr:`default_fallback_signers`.
  60  
  61      .. versionchanged:: 2.0
  62          Added support for key rotation by passing a list to
  63          ``secret_key``.
  64  
  65      .. versionchanged:: 2.0
  66          Removed the default SHA-512 fallback signer from
  67          ``default_fallback_signers``.
  68  
  69      .. versionchanged:: 1.1
  70          Added support for ``fallback_signers`` and configured a default
  71          SHA-512 fallback. This fallback is for users who used the yanked
  72          1.0.0 release which defaulted to SHA-512.
  73  
  74      .. versionchanged:: 0.14
  75          The ``signer`` and ``signer_kwargs`` parameters were added to
  76          the constructor.
  77      r�default_serializerztype[Signer]�default_signerzMlist[dict[str, t.Any] | tuple[type[Signer], dict[str, t.Any]] | type[Signer]]�default_fallback_signers�itsdangerousNr�Serializer[str]�
  78  secret_key�7str | bytes | cabc.Iterable[str] | cabc.Iterable[bytes]�salt�str | bytes | Noner�None | _PDataSerializer[str]�serializer_kwargs�dict[str, t.Any] | None�signer�type[Signer] | None�
  79  signer_kwargs�fallback_signers�Tlist[dict[str, t.Any] | tuple[type[Signer], dict[str, t.Any]] | type[Signer]] | NonecCrrr�rr)r+rr.r0r2r3rrr�__init__m�
  80  zSerializer.__init__�Serializer[bytes]�_PDataSerializer[bytes]cCrrrr5rrrr6}r7)r.r0r2r3cCrrrr5rrrr6��rcCrrrr5rrrr6�r7cCrrrr5rrrr6�r:�t.Any | NonecCs�t|�|_|dur
  81  t|�}||_|dur|j}||_t|�|_|dur&|j}||_|p,i|_	|dur7t
  82  |j�}||_|p=i|_
  83  dSr)r�secret_keysrr+r$rr"r%r0r2�listr&r3r.r5rrrr6�s"
  84  
  85  
  86  
  87  �r�bytescCs
  88  |jdS)z�The newest (last) entry in the :attr:`secret_keys` list. This
  89          is for compatibility from before key rotation support was added.
  90          �����)r<)rrrrr)�s
  91  zSerializer.secret_keyr
  92  �_PDataSerializer[t.Any] | Nonec
  93  Csl|dur|j}|j}n|}t|�}z|r|�|�d��WS|�|�WSty5}ztd|d�|�d}~ww)aLoads the encoded object. This function raises
  94          :class:`.BadPayload` if the payload is not valid. The
  95          ``serializer`` parameter can be used to override the serializer
  96          stored on the class. The encoded ``payload`` should always be
  97          bytes.
  98          N�utf-8zSCould not load the payload because an exception occurred on unserializing the data.)�original_error)rr"r�decode�	Exceptionr)rr
  99  rZuse_serializerZis_text�errr�load_payload�s$	����zSerializer.load_payloadrcCst|jj|fi|j���S)z�Dumps the encoded object. The return value is always bytes.
 100          If the internal serializer returns text, the value will be
 101          encoded as UTF-8.
 102          )rrrr.rrrr�dump_payloadszSerializer.dump_payloadrcCs(|dur|j}|j|jfd|i|j��S)z�Creates a new instance of the signer to be used. The default
 103          implementation uses the :class:`.Signer` base class.
 104          Nr+)r+r0r<r2)rr+rrr�make_signerszSerializer.make_signer�cabc.Iterator[Signer]ccs~�|dur|j}|�|�V|jD]+}t|t�r|}|j}n
 105  t|t�r(|\}}n|j}|jD]
 106  }||fd|i|��Vq.qdS)z�Iterates over all signers to be tried for unsigning. Starts
 107          with the configured signer, then constructs each signer
 108          specified in ``fallback_signers``.
 109          Nr+)	r+rHr3r �dictr0�tupler2r<)rr+�fallback�kwargsr)rrr�iter_unsigners!s�
 110  
 111  
 112  
 113  
 114  ��zSerializer.iter_unsignersr	cCs2t|�|��}|�|��|�}|jr|�d�S|S)z�Returns a signed string serialized with the internal
 115          serializer. The return value can be either a byte or unicode
 116          string depending on the format of the internal serializer.
 117          rA)rrGrH�signr"rC)rrr+r
 118  �rvrrrr7s
 119  
 120  zSerializer.dumps�f�t.IO[t.Any]�NonecCs|�|�||��dS)z�Like :meth:`dumps` but dumps into a file. The file handle has
 121          to be compatible with what the internal serializer expects.
 122          N)�writer)rrrQr+rrr�dumpDszSerializer.dump�s�str | bytesrMcKsft|�}d}|�|�D]!}z|�|�|��WSty,}z|}WYd}~qd}~wwt�t|��)ziReverse of :meth:`dumps`. Raises :exc:`.BadSignature` if the
 123          signature validation fails.
 124          N)rrNrFZunsignr�t�cast)rrVr+rMZlast_exceptionr0�errrrrrJs��zSerializer.loadscCs|�|��|�S)z)Like :meth:`loads` but loads from a file.)r�read�rrQr+rrr�load[szSerializer.load�tuple[bool, t.Any]cCs|�||�S)a9Like :meth:`loads` but without verifying the signature. This
 125          is potentially very dangerous to use depending on how your
 126          serializer works. The return value is ``(signature_valid,
 127          payload)`` instead of just the payload. The first item will be a
 128          boolean that indicates if the signature is valid. This function
 129          never fails.
 130  
 131          Use it for debugging only and if you know that your serializer
 132          module is not exploitable (for example, do not use it with a
 133          pickle serializer).
 134  
 135          .. versionadded:: 0.15
 136          )�_loads_unsafe_impl)rrVr+rrr�loads_unsafe_szSerializer.loads_unsafe�load_kwargs�load_payload_kwargscCs�|duri}zd|j|fd|i|��fWStyU}z5|jdur(WYd}~dS|dur.i}zd|j|jfi|��fWWYd}~StyPYWYd}~dSwd}~ww)zfLow level helper function to implement :meth:`loads_unsafe`
 137          in serializer subclasses.
 138          NTr+)FNF)rrr
 139  rFr)rrVr+rarbrErrrr_qs$
 140  
 141  ����zSerializer._loads_unsafe_implcCs|j|��|d�S)zYLike :meth:`loads_unsafe` but loads from a file.
 142  
 143          .. versionadded:: 0.15
 144          )r+)r`r[r\rrr�load_unsafe�szSerializer.load_unsafe)r'NNNNN)rr(r)r*r+r,rr-r.r/r0r1r2r/r3r4)NNNN)rr8r)r*r+r,rr9r.r/r0r1r2r/r3r4)r')r)r*r+r,rrr.r/r0r1r2r/r3r4)r)r*r+r,rr;r.r/r0r1r2r/r3r4)rr>r)r
 145  r>rr@rr)rrrr>)r+r,rr)r+r,rrI)rrr+r,rr	)rrrQrRr+r,rrS)rVrWr+r,rMrrr)rQrRr+r,rr)rVrWr+r,rr^)NN)
 146  rVrWr+r,rar/rbr/rr^)rQrRr+r,rr^)rrr�__doc__�jsonr$�__annotations__rr%r&rX�overloadr6�propertyr)rFrGrHrNrrUrr]r`r_rcrrrrr#*s�
 147  6
 148  ���������.�
 149  	
 150  ����r#)rrrr)�
 151  __future__r�collections.abc�abcZcabcre�typingrX�encodingr�excrrr0rr�
 152  TYPE_CHECKINGZtyping_extensions�te�TypeVar�Unionr!r>r	�Protocolrr"�Genericr#rrrr�<module>s$�
 153