o
    wvXjå<  ã                	   @   sR  d Z ddlmZmZ ddlZddlZddlZddlZzddl	Z
W n ey+   dZ
Y nw ddlmZ ddlmZ ddlmZ ddlmZmZmZmZ dd	lmZmZ dd
lmZ ddlmZmZmZ dZ e!ddgƒZ"e!ddgƒZ#ej$ %d¡r{dd„ Z&nej'Z&e
p�eZej(Z)e*ej+ ,dd¡ƒZ-eddƒZ.ee/feffdd„ƒZ0e)fdd„Z1dd„ Z2G dd„ de3ƒZ4e4ƒ Z5e5j6Z6e5j7Z7e5j8Z8e5j9Z9d d!„ Z:d"d#„ Z;d$d%„ Z<ej=d d&kr×d'd(„ Z>ne1Z>d)d*„ Z?d+d,„ Z@e;ƒ  e?ƒ  e<ƒ  e@ƒ  e5 Ad-¡ e;e?e<e@e;e<e?e@d.œZBe3ƒ ZCeCfd/d0„ZDeCfd1d2„ZEeEƒ  ed3ƒD ]\ZFZGe8eFjHgeG¢R Ž  �qd6d4d5„ZIdS )7zSerialization utilities.é    )Úabsolute_importÚunicode_literalsN)Ú
namedtuple)Úcontextmanager©ÚBytesIOé   )ÚContentDisallowedÚDecodeErrorÚEncodeErrorÚSerializerNotInstalled)ÚreraiseÚtext_t)Úentrypoints)Úbytes_to_strÚstr_to_bytesÚbytes_t)ÚpickleÚloadsÚdumpsÚregisterÚ
unregisterÚbinaryz
ascii-8bitúapplication/datazapplication/textÚjavac                 C   s   t  |¡| ƒd S )Nr   )ÚcodecsÚ
getdecoder)ÚtÚcoding© r   úP/var/www/html/myproject/venv/lib/python3.10/site-packages/kombu/serialization.pyÚ_decode   s   r!   ÚPICKLE_PROTOCOLé   Úcodec)Úcontent_typeÚcontent_encodingÚencoderc              
   c   s\   � zd V  W d S  |y   ‚  |y- } zt | | |ƒt ¡ d ƒ W Y d }~d S d }~ww )Nr#   )r   ÚsysÚexc_info)ÚwrapperÚincludeÚexcludeÚexcr   r   r    Ú_reraise_errors.   s   €&€ÿr.   c                 C   s   |t | ƒƒS ©Nr   )ÚsÚloadr   r   r    Úpickle_loads9   s   r2   c                 C   s   | rd| |f S |S )Nz%s (%s)r   )ÚfirstÚsecondr   r   r    Úparenthesize_alias>   s   r5   c                   @   sf   e Zd ZdZdd„ Z	ddd„Zdd„ Zd	d
„ Zdd„ Zdd„ Z	ddd„Z
ddefdd„Zdd„ ZdS )ÚSerializerRegistryz2The registry keeps track of serialization methods.c                 C   s6   i | _ i | _d | _d | _d | _tƒ | _i | _i | _d S r/   )	Ú	_encodersÚ	_decodersÚ_default_encodeÚ_default_content_typeÚ_default_content_encodingÚsetÚ_disabled_content_typesÚtype_to_nameÚname_to_type)Úselfr   r   r    Ú__init__E   s   
zSerializerRegistry.__init__úutf-8c                 C   s<   |rt |||ƒ| j|< |r|| j|< || j|< || j|< dS )aê  Register a new encoder/decoder.

        Arguments:
            name (str): A convenience name for the serialization method.

            encoder (callable): A method that will be passed a python data
                structure and should return a string representing the
                serialized data.  If :const:`None`, then only a decoder
                will be registered. Encoding will not be possible.

            decoder (Callable): A method that will be passed a string
                representing serialized data and should return a python
                data structure.  If :const:`None`, then only an encoder
                will be registered.  Decoding will not be possible.

            content_type (str): The mime-type describing the serialized
                structure.

            content_encoding (str): The content encoding (character set) that
                the `decoder` method will be returning. Will usually be
                `utf-8`, `us-ascii`, or `binary`.
        N)r$   r7   r8   r>   r?   )r@   Únamer'   Údecoderr%   r&   r   r   r    r   O   s   
ÿ

zSerializerRegistry.registerc                 C   ó"   d|vr	| j | }| j |¡ d S ©Nú/)r?   r=   Údiscard©r@   rC   r   r   r    Úenablep   ó   
zSerializerRegistry.enablec                 C   rE   rF   )r?   r=   ÚaddrI   r   r   r    Údisableu   rK   zSerializerRegistry.disablec                 C   sf   z$| j | }| j |d¡ | j |d¡ | j |d¡ | j  |d¡ W dS  ty2   td |¡ƒ‚w )zôUnregister registered encoder/decoder.

        Arguments:
            name (str): Registered serialization method name.

        Raises:
            SerializerNotInstalled: If a serializer by that name
                cannot be found.
        Nz$No encoder/decoder installed for {0})r?   r8   Úpopr7   r>   ÚKeyErrorr   Úformat)r@   rC   r%   r   r   r    r   z   s   

ÿÿzSerializerRegistry.unregisterc                 C   s:   z| j | \| _| _| _W dS  ty   td |¡ƒ‚w )a²  Set the default serialization method used by this library.

        Arguments:
            name (str): The name of the registered serialization method.
                For example, `json` (default), `pickle`, `yaml`, `msgpack`,
                or any custom methods registered using :meth:`register`.

        Raises:
            SerializerNotInstalled: If the serialization method
                requested is not available.
        úNo encoder installed for {0}N)r7   r:   r;   r9   rO   r   rP   rI   r   r   r    Ú_set_default_serializerŽ   s   
ÿ
ÿÿz*SerializerRegistry._set_default_serializerNc                 C   sö   |dkrt |ƒS |r| j |¡std |¡ƒ‚|s#t|tƒr#dd|fS |sJt|tƒrJtt	dd�� | 
d¡}W d  ƒ n1 s@w   Y  d	d|fS |rU| j| \}}}n	| j}| j}| j}tt	ƒ� ||ƒ}W d  ƒ n1 sqw   Y  |||fS )
a·  Encode data.

        Serialize a data structure into a string suitable for sending
        as an AMQP message body.

        Arguments:
            data (List, Dict, str): The message data to send.

            serializer (str): An optional string representing
                the serialization method you want the data marshalled
                into. (For example, `json`, `raw`, or `pickle`).

                If :const:`None` (default), then json will be used, unless
                `data` is a :class:`str` or :class:`unicode` object. In this
                latter case, no serialization occurs as it would be
                unnecessary.

                Note that if `serializer` is specified, then that
                serialization method will be used even if a :class:`str`
                or :class:`unicode` object is passed in.

        Returns:
            Tuple[str, str, str]: A three-item tuple containing the
            content type (e.g., `application/json`), content encoding, (e.g.,
            `utf-8`) and a string containing the serialized data.

        Raises:
            SerializerNotInstalled: If the serialization method
                requested is not available.
        ÚrawrQ   r   r   r   ©r,   rB   Nz
text/plain)Ú
raw_encoder7   Úgetr   rP   Ú
isinstancer   r   r.   r   Úencoder9   r:   r;   )r@   ÚdataÚ
serializerÚpayloadr%   r&   r'   r   r   r    r   ¡   s.   ÿ
ÿ

ÿ

ÿ
zSerializerRegistry.dumpsFc                 C   sè   |rt |ƒnd}|dur||vr||vr|  |d¡‚n|| jv r(|s(|  |d¡‚|p+d ¡ }|rr| j |¡}|rPttƒ� ||ƒW  d  ƒ S 1 sKw   Y  |tvrrt	|t
ƒsrttƒ� t||ƒW  d  ƒ S 1 smw   Y  |S )a“  Decode serialized data.

        Deserialize a data stream as serialized using `dumps`
        based on `content_type`.

        Arguments:
            data (bytes, buffer, str): The message data to deserialize.

            content_type (str): The content-type of the data.
                (e.g., `application/json`).

            content_encoding (str): The content-encoding of the data.
                (e.g., `utf-8`, `binary`, or `us-ascii`).

            accept (Set): List of content-types to accept.

        Raises:
            ContentDisallowed: If the content-type is not accepted.

        Returns:
            Any: The unserialized data.
        r   NÚ	untrustedÚdisabledrB   )r   Ú_for_untrusted_contentr=   Úlowerr8   rV   r.   r
   ÚSKIP_DECODErW   r   r!   )r@   rY   r%   r&   ÚacceptÚforceÚ_trusted_contentÚdecoder   r   r    r   à   s0   ÿ€
 ÿÿ
 ÿzSerializerRegistry.loadsc              	   C   s    t d |t| j ||¡|ƒ¡ƒS )Nz/Refusing to deserialize {0} content of type {1})r	   rP   r5   r>   rV   )r@   ÚctypeÚwhyr   r   r    r^     s   þÿz)SerializerRegistry._for_untrusted_content)rB   r/   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__rA   r   rJ   rM   r   rR   r   ÚTRUSTED_CONTENTr   r^   r   r   r   r    r6   B   s    
ÿ!
@
ÿ.r6   c                 C   s\   d}| }t |tƒr'd}ttdd�� | |¡}W d  ƒ n1 s!w   Y  nd}|||fS )zSpecial case serializer.r   rB   r   rT   Nr   )rW   r   r.   r   rX   )rY   r%   r[   r&   r   r   r    rU     s   
ÿ€
rU   c                  C   s(   ddl m}  tjd| j| jddd� dS )z2Register a encoder/decoder for JSON serialization.r   )Újsonrl   úapplication/jsonrB   ©r%   r&   N)Úkombu.utilsrl   Úregistryr   r   r   )Ú_jsonr   r   r    Úregister_json,  s
   
þrr   c               	   C   sT   zddl } tjd| j| jddd� W dS  ty)   dd„ }t dd|d¡ Y dS w )	z¸Register a encoder/decoder for YAML serialization.

    It is slower than JSON, but allows for more data types
    to be serialized. Useful if you need to send data such as dates

    r   NÚyamlúapplication/x-yamlrB   rn   c                  _   ó   t dƒ‚)zŒRaise SerializerNotInstalled.

            Used in case a client receives a yaml message, but yaml
            isn't installed.
            z9No decoder installed for YAML. Install the PyYAML library©r   ©ÚargsÚkwargsr   r   r    Únot_availableC  s   ÿz$register_yaml.<locals>.not_available)rs   rp   r   Ú	safe_dumpÚ	safe_loadÚImportError)rs   rz   r   r   r    Úregister_yaml5  s   þör~   é   c                 C   s   t t| ƒƒS r/   )r2   r   ©r0   r   r   r    ÚunpickleP  ó   r�   c                  C   s&   t jfdd„} tjd| tddd� dS )zpRegister pickle serializer.

    The fastest serialization method, but restricts
    you to python clients.
    c                 S   s   || t d�S )N)Úprotocol)Úpickle_protocol)ÚobjÚdumperr   r   r    Úpickle_dumps]  r‚   z%register_pickle.<locals>.pickle_dumpsr   úapplication/x-python-serializer   rn   N)r   r   rp   r   r�   )r‡   r   r   r    Úregister_pickleW  s
   

þr‰   c               	      s˜   d } }z(ddl }|jdkr#ddl m‰ m‰ ‡ fdd„} ‡fdd„}nd	d
„ }| } }W n ttfy?   dd„ }| } }Y nw tjd| |ddd� dS )zNRegister msgpack serializer.

    See Also:
        https://msgpack.org/.
    Nr   )r   é   ©ÚpackbÚunpackbc                    ó   ˆ | dd�S )NT)Úuse_bin_typer   r€   )rŒ   r   r    Úpackq  r‚   zregister_msgpack.<locals>.packc                    rŽ   )NF)rS   r   r€   )r�   r   r    Úunpackt  r‚   z register_msgpack.<locals>.unpackc                  _   ru   )Nz(msgpack requires msgpack-python >= 0.4.0rv   rw   r   r   r    Úversion_mismatchw  ó   ÿz*register_msgpack.<locals>.version_mismatchc                  _   ru   )NzKNo decoder installed for msgpack. Please install the msgpack-python libraryrv   rw   r   r   r    rz   |  r“   z'register_msgpack.<locals>.not_availableÚmsgpackúapplication/x-msgpackr   rn   )r”   ÚversionrŒ   r�   r}   Ú
ValueErrorrp   r   )r�   r‘   r”   r’   rz   r   r‹   r    Úregister_msgpacke  s&   
€û
ýr˜   rl   )rl   r   rs   r”   rm   rt   rˆ   r•   c              	   C   sN   | t u rg d¢n| } | dur#| D ]}zt |¡ W q ty"   Y qw dS dS )zíEnable serializers that are considered to be unsafe.

    Note:
        Will enable ``pickle``, ``yaml`` and ``msgpack`` by default, but you
        can also specify a list of serializers (by name or content type)
        to enable.
    )r   rs   r”   N)ÚNOTSETrp   rJ   rO   )ÚchoicesÚchoicer   r   r    Úenable_insecure_serializers   s   ÿürœ   c                 C   sL   | t u rdgn| } tjD ]}t |¡ q| dur"| D ]	}t |¡ qdS dS )aA  Disable untrusted serializers.

    Will disable all serializers except ``json``
    or you can specify a list of deserializers to allow.

    Note:
        Producers will still be able to serialize data
        in these formats, but consumers will not accept
        incoming data using the untrusted content types.
    rl   N)r™   rp   r8   rM   rJ   )ÚallowedrC   r   r   r    Údisable_insecure_serializers±  s   
þrž   zkombu.serializersc                    s,   ˆ st jnˆ ‰ | d ur‡ fdd„| D ƒS | S )Nc                    s    h | ]}d |v r
|nˆ | ’qS )rG   r   )Ú.0Ún©r?   r   r    Ú	<setcomp>Ï  s     z)prepare_accept_content.<locals>.<setcomp>)rp   r?   )Úcontent_typesr?   r   r¡   r    Úprepare_accept_contentÌ  s   r¤   r/   )Jrj   Ú
__future__r   r   r   Úosr(   r   ÚpypickleÚcPickleÚcpickler}   Úcollectionsr   Ú
contextlibr   Úior   Ú
exceptionsr	   r
   r   r   Úfiver   r   Úutils.compatr   Úutils.encodingr   r   r   Ú__all__Ú	frozensetr`   rk   ÚplatformÚ
startswithr!   rd   r1   Úpickle_loadÚintÚenvironrV   r„   r$   Ú	Exceptionr.   r2   r5   Úobjectr6   rp   r   r   r   r   rU   rr   r~   Úversion_infor�   r‰   r˜   rR   Ú
_setupfunsr™   rœ   rž   Úeprx   rC   r¤   r   r   r   r    Ú<module>   sŠ    ÿ

ÿ
 W	
$
ø