4V=j<ddlmZddlmZddlZddlZddlm Z ddl m Z ddl m Z ddl mZddl mZejr2ddlZejd ejeefejeef Znejd ejeef ZGd d ejeZddZGddejeZdS)) annotationsN) want_bytes) BadPayload) BadSignature)_make_keys_list)Signer _TSerialized)bounddefault)r ceZdZd dZd dZdS) _PDataSerializerpayloadr returnt.AnycdSN)selfrs EC:\PYTHON\_runtimes\venv\Lib\site-packages\itsdangerous/serializer.pyloadsz_PDataSerializer.loadsobjcdSrrrrs rdumpsz_PDataSerializer.dumpsrrN)rr rr)rrrr )__name__ __module__ __qualname__rrrrrrrs*;;;;877777rr serializer_PDataSerializer[t.Any]r#te.TypeGuard[_PDataSerializer[str]]cRt|itS)z5Checks whether a serializer generates text or binary.) isinstancerstr)r!s ris_text_serializerr'#s" j&&r**C 0 00rceZdZUdZeZded<eZded<gZ ded<e j dAdBdZ e j dCdDdZ e j dEd d d d ddDdZ e j dCdFd Z e j dEd d d d ddFd!Z dAdGd#Z e dHd&Z dIdJd)ZdKd+ZdIdLd-ZdIdMd/ZdIdNd1ZdIdOd5Z dIdPd9ZdIdQd:Z dIdRd<Z dSdTd?Z dIdUd@Zd S)V Serializera: A serializer wraps a :class:`~itsdangerous.signer.Signer` to enable serializing and securely signing data other than bytes. It can unsign to verify that the data hasn't been changed. The serializer provides :meth:`dumps` and :meth:`loads`, similar to :mod:`json`, and by default uses :mod:`json` internally to serialize the data to bytes. The secret key should be a random string of ``bytes`` and should not be saved to code or version control. Different salts should be used to distinguish signing in different contexts. See :doc:`/concepts` for information about the security of the secret key and salt. :param secret_key: The secret key to sign and verify with. Can be a list of keys, oldest to newest, to support key rotation. :param salt: Extra key to combine with ``secret_key`` to distinguish signatures in different contexts. :param serializer: An object that provides ``dumps`` and ``loads`` methods for serializing data to a string. Defaults to :attr:`default_serializer`, which defaults to :mod:`json`. :param serializer_kwargs: Keyword arguments to pass when calling ``serializer.dumps``. :param signer: A ``Signer`` class to instantiate when signing data. Defaults to :attr:`default_signer`, which defaults to :class:`~itsdangerous.signer.Signer`. :param signer_kwargs: Keyword arguments to pass when instantiating the ``Signer`` class. :param fallback_signers: List of signer parameters to try when unsigning with the default signer fails. Each item can be a dict of ``signer_kwargs``, a ``Signer`` class, or a tuple of ``(signer, signer_kwargs)``. Defaults to :attr:`default_fallback_signers`. .. versionchanged:: 2.0 Added support for key rotation by passing a list to ``secret_key``. .. versionchanged:: 2.0 Removed the default SHA-512 fallback signer from ``default_fallback_signers``. .. versionchanged:: 1.1 Added support for ``fallback_signers`` and configured a default SHA-512 fallback. This fallback is for users who used the yanked 1.0.0 release which defaulted to SHA-512. .. versionchanged:: 0.14 The ``signer`` and ``signer_kwargs`` parameters were added to the constructor. r"default_serializerz type[Signer]default_signerzMlist[dict[str, t.Any] | tuple[type[Signer], dict[str, t.Any]] | type[Signer]]default_fallback_signers itsdangerousNrSerializer[str] secret_key7str | bytes | cabc.Iterable[str] | cabc.Iterable[bytes]saltstr | bytes | Noner!None | _PDataSerializer[str]serializer_kwargsdict[str, t.Any] | Nonesignertype[Signer] | None signer_kwargsfallback_signersTlist[dict[str, t.Any] | tuple[type[Signer], dict[str, t.Any]] | type[Signer]] | NonecdSrrrr/r1r!r4r6r8r9s r__init__zSerializer.__init__m  srSerializer[bytes]_PDataSerializer[bytes]cdSrrr<s rr=zSerializer.__init__}r>r)r4r6r8r9cdSrrr<s rr=zSerializer.__init__  srrcdSrrr<s rr=zSerializer.__init__r>rcdSrrr<s rr=zSerializer.__init__rCr t.Any | Nonec$t||_|t|}||_||j}||_t ||_||j}||_|pi|_ |t|j }||_ |pi|_ dSr)r secret_keysrr1r*r!r'r+r6r8listr,r9r4r<s rr=zSerializer.__init__s$)8 (C(C  d##D  0J:D(::(F(F >(F$* /d}~wwxYwt jt|)ziReverse of :meth:`dumps`. Raises :exc:`.BadSignature` if the signature validation fails. N)rrarVunsignrtcast)rrkr1r`last_exceptionr6errs rrzSerializer.loadsJs qMM))$// % %F %((q)9)9::::: % % %!$ %f\>222s'A A*A%%A*cR|||S)z)Like :meth:`loads` but loads from a file.)rreadrrer1s rloadzSerializer.load[szz!&&((D)))rtuple[bool, t.Any]c.|||S)a9Like :meth:`loads` but without verifying the signature. This is potentially very dangerous to use depending on how your serializer works. The return value is ``(signature_valid, payload)`` instead of just the payload. The first item will be a boolean that indicates if the signature is valid. This function never fails. Use it for debugging only and if you know that your serializer module is not exploitable (for example, do not use it with a pickle serializer). .. versionadded:: 0.15 )_loads_unsafe_impl)rrkr1s r loads_unsafezSerializer.loads_unsafe_s &&q$///r load_kwargsload_payload_kwargsc|i} d|j|fd|i|fS#t$rF}|jYd}~dS|i} d|j|jfi|fcYd}~S#t$rYYd}~dSwxYwd}~wwxYw)zfLow level helper function to implement :meth:`loads_unsafe` in serializer subclasses. NTr1)FNF)rrrrVr)rrkr1r{r|rUs rryzSerializer._loads_unsafe_implqs  K #A@@D@K@@@ @ # # #y "{{{{{"*&(# #%D%aiGG3FGG # # #"{{{{{{ # #s< A(A#A#AA( A A#A  A##A(cT|||S)zYLike :meth:`loads_unsafe` but loads from a file. .. versionadded:: 0.15 )r1)rzrtrus r load_unsafezSerializer.load_unsafes%   555r)r-NNNNN)rr.r/r0r1r2r!r3r4r5r6r7r8r5r9r:)NNNN)rr?r/r0r1r2r!r@r4r5r6r7r8r5r9r:)r-)r/r0r1r2r!rr4r5r6r7r8r5r9r:)r/r0r1r2r!rFr4r5r6r7r8r5r9r:)rrJr)rrJr!rMrr)rrrrJ)r1r2rr )r1r2rr[)rrr1r2rr )rrrerfr1r2rrg)rkrlr1r2r`rrr)rerfr1r2rr)rkrlr1r2rrw)NN) rkrlr1r2r{r5r|r5rrw)rerfr1r2rrw)rrr __doc__jsonr*__annotations__r r+r,rooverloadr=propertyr/rVrXrZrarrjrrvrzryrrrrr)r)*s,11l376666$*N))))     Z$33759&*15     Z  Z 6:&*15     Z  Z$3  6:&*15      Z  $Z 6:&*15     Z  Z$3  6:&*15      Z  $$3#'59&*15,K,K,K,K,K\$$$X$LP8PPPPNNNNN@@@@@,     ''''':>33333"***** :>00000,047; #####>:>6666666rr))r!r"rr#) __future__rcollections.abcabccabcrtypingroencodingrexcrrr6rr TYPE_CHECKINGtyping_extensionsteTypeVarUnionr&rJr Protocolrr'Genericr)rrrrs""""""  ######? H""""2:agc5j1173:;NLL 19^173:3FGGGL88888qz,/8881111l6l6l6l6l6<(l6l6l6l6l6r