a
    Lcòf�"  ã                   @   s"  d dl Z d dlZd dlZd dlmZ d dlmZ d dlmZ G dd„ de	ƒZ
d,d
d„ZedƒeeeejejejfZdd„ Zd-dd„Zd.dd„Zd/dd„Zdd„ Zg d¢eddƒeddƒgZdd„ eD ƒZdZe dd„ edd… D ƒ¡ d d!„ Zd"d#„ Zd$d%„ Zd&d'„ Zd(d)„ Z d*d+„ Z!e!ƒ Z"dS )0é    N)ÚDecimal©Úquote)ÚPromisec                       s(   e Zd Z‡ fdd„Z‡ fdd„Z‡  ZS )ÚDjangoUnicodeDecodeErrorc                    s   || _ tƒ j|Ž  d S )N)ÚobjÚsuperÚ__init__)Úselfr   Úargs©Ú	__class__© úR/home/httpd/docs/test/DocsMgr/lib/python3.9/site-packages/django/utils/encoding.pyr	      s    z!DjangoUnicodeDecodeError.__init__c                    s   dt ƒ  ¡ | jt| jƒf S )Nz%s. You passed in %r (%s))r   Ú__str__r   Útype)r
   r   r   r   r      s
    ýz DjangoUnicodeDecodeError.__str__)Ú__name__Ú
__module__Ú__qualname__r	   r   Ú__classcell__r   r   r   r   r   
   s   r   úutf-8FÚstrictc                 C   s   t | tƒr| S t| |||ƒS )z©
    Return a string representing 's'. Treat bytestrings using the 'encoding'
    codec.

    If strings_only is True, don't convert (some) non-string-like objects.
    )Ú
isinstancer   Ú	force_str©ÚsÚencodingÚstrings_onlyÚerrorsr   r   r   Ú	smart_str   s    
r   c                 C   s
   t | tƒS )z¢Determine if the object instance is of a protected type.

    Objects of protected types are preserved as-is when passed to
    force_str(strings_only=True).
    )r   Ú_PROTECTED_TYPES)r   r   r   r   Úis_protected_type/   s    r!   c              
   C   s‚   t t| ƒtƒr| S |r"t| ƒr"| S z$t| tƒr<t| ||ƒ} nt| ƒ} W n6 ty| } zt| g|j¢R Ž ‚W Y d}~n
d}~0 0 | S )zÇ
    Similar to smart_str(), except that lazy instances are resolved to
    strings, rather than kept as lazy objects.

    If strings_only is True, don't convert (some) non-string-like objects.
    N)	Ú
issubclassr   Ústrr!   r   ÚbytesÚUnicodeDecodeErrorr   r   )r   r   r   r   Úer   r   r   r   8   s    
(r   c                 C   s   t | tƒr| S t| |||ƒS )z�
    Return a bytestring version of 's', encoded as specified in 'encoding'.

    If strings_only is True, don't convert (some) non-string-like objects.
    )r   r   Úforce_bytesr   r   r   r   Úsmart_bytesN   s    
r(   c                 C   s\   t | tƒr*|dkr| S |  d|¡ ||¡S |r:t| ƒr:| S t | tƒrLt| ƒS t| ƒ ||¡S )zÇ
    Similar to smart_bytes, except that lazy instances are resolved to
    strings, rather than kept as lazy objects.

    If strings_only is True, don't convert (some) non-string-like objects.
    r   )r   r$   ÚdecodeÚencoder!   Ú
memoryviewr#   r   r   r   r   r'   Z   s    

r'   c                 C   s*   | du r| S t | tƒrt| ƒ} t| dd�S )uï  
    Convert an Internationalized Resource Identifier (IRI) portion to a URI
    portion that is suitable for inclusion in a URL.

    This is the algorithm from RFC 3987 Section 3.1, slightly simplified since
    the input is assumed to be a string rather than an arbitrary byte stream.

    Take an IRI (string or UTF-8 bytes, e.g. '/I â™¥ Django/' or
    b'/I Ã¢Â™Â¥ Django/') and return a string containing the encoded
    result with ASCII chars only (e.g. '/I%20%E2%99%A5%20Django/').
    Nz/#%[]=:;$&()+,!?*@'~©Úsafe)r   r   r#   r   )Úirir   r   r   Ú
iri_to_urin   s
    
r/   )é-   é.   é_   é~   éA   é[   éa   é{   c                 C   s4   i | ],}|D ]"}d D ]}||   ¡ t|fƒ“qqqS ))z%02xz%02X)r*   r$   )Ú.0Zascii_rangeÚcharÚfmtr   r   r   Ú
<dictcomp>�   s   ýr;   Ú0123456789ABCDEFabcdefc                 C   s.   i | ]&}t D ]}||  ¡ t || ¡“qqS r   )Ú_hexdigr*   r$   Úfromhex)r8   ÚaÚbr   r   r   r;   š   ó    é   c                 C   s¶   | du r| S t | ƒ} |  d¡}t|ƒdkr0| }nz|d g}|j}t}|dd… D ]N}|dd… }||v rŽ|||dd…  ƒ ||dd… ƒ qP|dƒ ||ƒ qPd |¡}t|ƒ ¡ S )uI  
    Convert a Uniform Resource Identifier(URI) into an Internationalized
    Resource Identifier(IRI).

    This is the algorithm from RFC 3987 Section 3.2, excluding step 4.

    Take an URI in ASCII bytes (e.g. '/I%20%E2%99%A5%20Django/') and return
    a string containing the encoded result (e.g. '/I%20â™¥%20Django/').
    Nó   %é   r   é   rA   )r'   ÚsplitÚlenÚappendÚ
_hextobyteÚjoinÚrepercent_broken_unicoder)   )ÚuriÚbitsr.   ÚpartsrH   Z	hextobyteÚitemÚhexr   r   r   Ú
uri_to_iriž   s$    




rQ   c                 C   s   t | dd�S )zh
    Escape the unsafe characters from the path portion of a Uniform Resource
    Identifier (URI).
    z/:@&+$,-_.!~*'()r,   r   ©Úpathr   r   r   Úescape_uri_pathÂ   s    rT   c                 C   s   |   d¡ d¡S )z:Return the Punycode of the given domain if it's non-ASCII.ÚidnaÚascii)r*   r)   )Údomainr   r   r   ÚpunycodeÓ   s    rX   c              
   C   sŒ   g }z|   ¡  W nf tyv } zNt| |j|j… dd�}| | d|j… | ¡  ¡ | |jd… } W Y d}~qd}~0 0 d |¡|  S qdS )z¹
    As per RFC 3987 Section 3.2, step three of converting a URI into an IRI,
    repercent-encode any octet produced that is not part of a strictly legal
    UTF-8 octet sequence.
    s   /#%[]=:;$&()+,!?*@'~r,   NrA   )r)   r%   r   ÚstartÚendrH   r*   rJ   )rS   Zchanged_partsr&   Z	repercentr   r   r   rK   Ø   s    $rK   c                 C   s$   | du r| S t t| ƒ dd¡dd�S )aA  Convert a file system path to a URI portion that is suitable for
    inclusion in a URL.

    Encode certain chars that would normally be recognized as special chars
    for URIs. Do not encode the ' character, as it is a valid character
    within URIs. See the encodeURIComponent() JavaScript function for details.
    Nú\ú/z/~!*()'r,   )r   r#   ÚreplacerR   r   r   r   Úfilepath_to_uriì   s    r^   c                  C   s:   zt  ¡ d pd} t | ¡ W n ty4   d} Y n0 | S )z¸
    The encoding for the character type functions. Fallback to 'ascii' if the
    #encoding is unsupported by Python or could not be determined. See tickets
    #10335 and #5846.
    rD   rV   )ÚlocaleÚ	getlocaleÚcodecsÚlookupÚ	Exception)r   r   r   r   Úget_system_encodingû   s    
rd   )r   Fr   )r   Fr   )r   Fr   )r   Fr   )#ra   Údatetimer_   Údecimalr   Úurllib.parser   Zdjango.utils.functionalr   r%   r   r   r   ÚintÚfloatÚdateÚtimer    r!   r   r(   r'   r/   ÚrangeZ_ascii_rangesrI   r=   ÚupdaterQ   rT   rX   rK   r^   rd   ZDEFAULT_LOCALE_ENCODINGr   r   r   r   Ú<module>   sF   
ù	


!þÿ$