o
    ˜¨Êhò`  ã                   @   sv  d dl Z d dlZd dlmZ d dlmZ d dlmZmZm	Z	m
Z
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 d d	lmZmZ d d
l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% d dl&m'Z' ddl(m)Z) e*ƒ Z+e'dƒZ,G dd„ de-ƒZ.G dd„ de/ƒZ0G dd„ dƒZ1G dd„ deƒZ2G dd„ deƒZ3G dd„ dƒZ4dd„ Z5d d!„ Z6d"d#„ Z7d$d%„ Z8dS )&é    N)ÚBytesIO)Úchain)Ú	parse_qslÚquoteÚ	urlencodeÚurljoinÚurlsplit)Úsettings)Úsigning)ÚDisallowedHostÚImproperlyConfiguredÚRequestDataTooBigÚTooManyFieldsSent)Úuploadhandler)ÚMultiPartParserÚMultiPartParserError)ÚCaseInsensitiveMappingÚImmutableListÚMultiValueDict)Úescape_uri_pathÚ
iri_to_uri)Úcached_property)Úis_same_domainÚparse_header_parameters)Ú_lazy_re_compileé   )Úparse_headerz4^([a-z0-9.-]+|\[[a-f0-9]*:[a-f0-9\.:]+\])(:[0-9]+)?$c                   @   s   e Zd ZdS )ÚUnreadablePostErrorN)Ú__name__Ú
__module__Ú__qualname__© r!   r!   úE/var/www/html/env/lib/python3.10/site-packages/django/http/request.pyr   #   s    r   c                   @   s   e Zd ZdZdS )ÚRawPostDataExceptionzŽ
    You cannot access raw_post_data from a request that has
    multipart/* POST data if it has been accessed via POST,
    FILES, etc..
    N)r   r   r    Ú__doc__r!   r!   r!   r"   r#   '   s    r#   c                   @   sN  e Zd ZdZdZg Zdd„ Zdd„ Zedd„ ƒZ	ed	d
„ ƒZ
dd„ Zdd„ Zdd„ Zdd„ Zdd„ ZdCdd„ZdCdd„Zdd„ Zeddfdd„ZdDdd „Zed!d"„ ƒZd#d$„ Zed%d&„ ƒZd'd(„ Zed)d*„ ƒZejd+d*„ ƒZd,d-„ Zed.d/„ ƒZejd0d/„ ƒZd1d2„ Zed3d4„ ƒZ d5d6„ Z!d7d8„ Z"d9d:„ Z#d;d<„ Z$d=d>„ Z%d?d@„ Z&dAdB„ Z'dS )EÚHttpRequestzA basic HTTP request.Nc                 C   sT   t dd�| _t dd�| _i | _i | _tƒ | _d| _d| _d | _	d | _
d | _d | _d S )NT)ÚmutableÚ )Ú	QueryDictÚGETÚPOSTÚCOOKIESÚMETAr   ÚFILESÚpathÚ	path_infoÚmethodÚresolver_matchÚcontent_typeÚcontent_params©Úselfr!   r!   r"   Ú__init__8   s   
zHttpRequest.__init__c                 C   s6   | j d u s	|  ¡ sd| jj S d| jj| j |  ¡ f S )Nz<%s>z<%s: %s %r>)r0   Úget_full_pathÚ	__class__r   r4   r!   r!   r"   Ú__repr__J   s   ýzHttpRequest.__repr__c                 C   s
   t | jƒS ©N)ÚHttpHeadersr,   r4   r!   r!   r"   ÚheadersS   ó   
zHttpRequest.headersc                 C   s   t | j dd¡ƒS )z%Return a list of MediaType instances.ÚAcceptz*/*)Úparse_accept_headerr<   Úgetr4   r!   r!   r"   Úaccepted_typesW   s   zHttpRequest.accepted_typesc                    s   t ‡ fdd„| jD ƒƒS )Nc                 3   s   � | ]}|  ˆ ¡V  qd S r:   )Úmatch)Ú.0Úaccepted_type©Ú
media_typer!   r"   Ú	<genexpr>]   s   € 

ÿz&HttpRequest.accepts.<locals>.<genexpr>)ÚanyrA   )r5   rF   r!   rE   r"   Úaccepts\   s   ÿzHttpRequest.acceptsc                 C   s`   t | dd¡ƒ\| _| _d| jv r.z
t | jd ¡ W n
 ty%   Y dS w | jd | _dS dS )z/Set content_type, content_params, and encoding.ÚCONTENT_TYPEr'   ÚcharsetN)r   r@   r2   r3   ÚcodecsÚlookupÚLookupErrorÚencoding)r5   Úmetar!   r!   r"   Ú_set_content_type_paramsa   s   
ÿ
ÿúz$HttpRequest._set_content_type_paramsc                 C   sl   t jrd| jv r| jd }|S d| jv r| jd }|S | jd }|  ¡ }||  ¡ r+dndkr4d||f }|S )z—
        Return the HTTP host using the environment or request headers. Skip
        allowed hosts protection, so may return an insecure host.
        ÚHTTP_X_FORWARDED_HOSTÚ	HTTP_HOSTÚSERVER_NAMEÚ443Ú80z%s:%s)r	   ÚUSE_X_FORWARDED_HOSTr,   Úget_portÚ	is_secure)r5   ÚhostÚserver_portr!   r!   r"   Ú_get_raw_hostn   s   
	
ø

üzHttpRequest._get_raw_hostc                 C   sn   |   ¡ }tj}tjr|sg d¢}t|ƒ\}}|rt||ƒr|S d| }|r/|d| 7 }t|ƒ‚|d7 }t|ƒ‚)z>Return the HTTP host using the environment or request headers.)z
.localhostz	127.0.0.1z[::1]zInvalid HTTP_HOST header: %r.z) You may need to add %r to ALLOWED_HOSTS.zB The domain name provided is not valid according to RFC 1034/1035.)r\   r	   ÚALLOWED_HOSTSÚDEBUGÚsplit_domain_portÚvalidate_hostr   )r5   rZ   Úallowed_hostsÚdomainÚportÚmsgr!   r!   r"   Úget_host€   s   
ýÿzHttpRequest.get_hostc                 C   s4   t jrd| jv r| jd }t|ƒS | jd }t|ƒS )z3Return the port number for the request as a string.ÚHTTP_X_FORWARDED_PORTÚSERVER_PORT)r	   ÚUSE_X_FORWARDED_PORTr,   Ústr)r5   rc   r!   r!   r"   rX   –   s
   

ÿzHttpRequest.get_portFc                 C   ó   |   | j|¡S r:   )Ú_get_full_pathr.   ©r5   Úforce_append_slashr!   r!   r"   r7   ž   ó   zHttpRequest.get_full_pathc                 C   rj   r:   )rk   r/   rl   r!   r!   r"   Úget_full_path_info¡   rn   zHttpRequest.get_full_path_infoc              	   C   sL   dt |ƒ|r| d¡sdnd| j dd¡r"dt| j dd¡ƒ f S df S )Nú%s%s%sú/r'   ÚQUERY_STRINGú?)r   Úendswithr,   r@   r   )r5   r.   rm   r!   r!   r"   rk   ¤   s   ÿýûzHttpRequest._get_full_pathr'   c                 C   st   z| j | }W n ty   |tur| Y S ‚ w ztj|| d�j||d�}W |S  tjy9   |tur8| Y S ‚ w )z×
        Attempt to return a signed cookie. If the signature fails or the
        cookie has expired, raise an exception, unless the `default` argument
        is provided,  in which case return that value.
        )Úsalt)Úmax_age)r+   ÚKeyErrorÚRAISE_ERRORr
   Úget_cookie_signerÚunsignÚBadSignature)r5   ÚkeyÚdefaultru   rv   Úcookie_valueÚvaluer!   r!   r"   Úget_signed_cookie¯   s"   üÿûüzHttpRequest.get_signed_cookiec                 C   s    |du rd|   ¡  }nt|ƒ}t|ƒ}|jr|jsL|j d¡rC|jsC|jsCd|jvrCd|jvrC| d¡r:|dd… }| j| }t	|ƒS t| j| j |ƒ}t	|ƒS )aÆ  
        Build an absolute URI from the location and the variables available in
        this request. If no ``location`` is specified, build the absolute URI
        using request.get_full_path(). If the location is absolute, convert it
        to an RFC 3987 compliant URI and return it. If location is relative or
        is scheme-relative (i.e., ``//example.com/``), urljoin() it to a base
        URL constructed from the request variables.
        Nz//%srq   z/./z/../z//é   )
r7   ri   r   ÚschemeÚnetlocr.   Ú
startswithÚ_current_scheme_hostr   r   )r5   ÚlocationÚbitsr!   r!   r"   Úbuild_absolute_uriÇ   s&   	
ÿþý



ÿzHttpRequest.build_absolute_uric                 C   s   d  | j|  ¡ ¡S )Nz{}://{})Úformatr‚   re   r4   r!   r!   r"   r…   ð   s   z HttpRequest._current_scheme_hostc                 C   s   dS )zf
        Hook for subclasses like WSGIRequest to implement. Return 'http' by
        default.
        Úhttpr!   r4   r!   r!   r"   Ú_get_schemeô   s   zHttpRequest._get_schemec                 C   sl   t jr2zt j\}}W n ty   tdƒ‚w | j |¡}|d ur2| dd¡^}}| ¡ |kr0dS dS |  ¡ S )NzJThe SECURE_PROXY_SSL_HEADER setting must be a tuple containing two values.ú,r   ÚhttpsrŠ   )	r	   ÚSECURE_PROXY_SSL_HEADERÚ
ValueErrorr   r,   r@   ÚsplitÚstripr‹   )r5   ÚheaderÚsecure_valueÚheader_valueÚ_r!   r!   r"   r‚   û   s   ÿÿzHttpRequest.schemec                 C   s
   | j dkS )Nr�   )r‚   r4   r!   r!   r"   rY     s   
zHttpRequest.is_securec                 C   s   | j S r:   ©Ú	_encodingr4   r!   r!   r"   rO     s   zHttpRequest.encodingc                 C   s*   || _ t| dƒr
| `t| dƒr| `dS dS )zÓ
        Set the encoding used for GET/POST accesses. If the GET or POST
        dictionary has already been created, remove and recreate it on the
        next access (so that it is decoded correctly).
        r)   Ú_postN)r—   Úhasattrr)   r˜   )r5   Úvalr!   r!   r"   rO     s   

ÿc                    s   ‡ fdd„t jD ƒˆ _d S )Nc                    s   g | ]}t  |ˆ ¡‘qS r!   )r   Úload_handler)rC   Úhandlerr4   r!   r"   Ú
<listcomp>   s    
ÿÿz4HttpRequest._initialize_handlers.<locals>.<listcomp>)r	   ÚFILE_UPLOAD_HANDLERSÚ_upload_handlersr4   r!   r4   r"   Ú_initialize_handlers  s   
þz HttpRequest._initialize_handlersc                 C   s   | j s|  ¡  | j S r:   )rŸ   r    r4   r!   r!   r"   Úupload_handlers%  s   zHttpRequest.upload_handlersc                 C   s   t | dƒr	tdƒ‚|| _d S )NÚ_fileszGYou cannot set the upload handlers after the upload has been processed.)r™   ÚAttributeErrorrŸ   )r5   r¡   r!   r!   r"   r¡   ,  s
   
ÿ
c                 C   s*   t | jdd�| _t||| j| jƒ}| ¡ S )z9Return a tuple of (POST QueryDict, FILES MultiValueDict).zEYou cannot alter upload handlers after the upload has been processed.)Úwarning)r   r¡   r   rO   Úparse)r5   r,   Ú	post_dataÚparserr!   r!   r"   Úparse_file_upload5  s   ýzHttpRequest.parse_file_uploadc              
   C   sŠ   t | dƒsB| jrtdƒ‚tjd ur"t| j d¡pdƒtjkr"tdƒ‚z|  	¡ | _
W n ty; } zt|jŽ |‚d }~ww t| j
ƒ| _| j
S )NÚ_bodyz?You cannot access body after reading from request's data streamÚCONTENT_LENGTHr   z;Request body exceeded settings.DATA_UPLOAD_MAX_MEMORY_SIZE.)r™   Ú_read_startedr#   r	   ÚDATA_UPLOAD_MAX_MEMORY_SIZEÚintr,   r@   r   Úreadr©   ÚOSErrorr   Úargsr   Ú_stream)r5   Úer!   r!   r"   ÚbodyA  s(   
ÿ
ÿÿ€ÿzHttpRequest.bodyc                 C   s   t ƒ | _tƒ | _d S r:   )r(   r˜   r   r¢   r4   r!   r!   r"   Ú_mark_post_parse_errorZ  s   z"HttpRequest._mark_post_parse_errorc                 C   sâ   | j dkrt| jd�tƒ | _| _dS | jr!t| dƒs!|  ¡  dS | j	dkrNt| dƒr1t
| jƒ}n| }z|  | j|¡\| _| _W dS  tyM   |  ¡  ‚ w | j	dkrct| j| jd�tƒ | _| _dS t| jd�tƒ | _| _dS )zFPopulate self._post and self._files if the content-type is a form typer*   )rO   Nr©   zmultipart/form-dataz!application/x-www-form-urlencoded)r0   r(   r—   r   r˜   r¢   r«   r™   r´   r2   r   r©   r¨   r,   r   r³   )r5   Údatar!   r!   r"   Ú_load_post_and_files^  s2   


þ

ú
þ
þz HttpRequest._load_post_and_filesc                 C   s:   t | dƒrt dd„ | j ¡ D ƒ¡D ]}| ¡  qd S d S )Nr¢   c                 s   s   � | ]}|d  V  qdS )r   Nr!   )rC   Úlist_r!   r!   r"   rG   †  s   € z$HttpRequest.close.<locals>.<genexpr>)r™   r   Úfrom_iterabler¢   ÚlistsÚclose)r5   Úfr!   r!   r"   rº   „  s
   

þzHttpRequest.closec              
   O   ó@   d| _ z
| jj|i |¤ŽW S  ty } zt|jŽ |‚d }~ww ©NT)r«   r±   r®   r¯   r   r°   ©r5   r°   Úkwargsr²   r!   r!   r"   r®   ‘  ó   €ÿzHttpRequest.readc              
   O   r¼   r½   )r«   r±   Úreadliner¯   r   r°   r¾   r!   r!   r"   rÁ   ˜  rÀ   zHttpRequest.readlinec                 C   s   t | jdƒS )Nó    )ÚiterrÁ   r4   r!   r!   r"   Ú__iter__Ÿ  ó   zHttpRequest.__iter__c                 C   s   t | ƒS r:   )Úlistr4   r!   r!   r"   Ú	readlines¢  s   zHttpRequest.readlines)Fr:   )(r   r   r    r$   r—   rŸ   r6   r9   r   r<   rA   rI   rQ   r\   re   rX   r7   ro   rk   rx   r€   rˆ   r…   r‹   Úpropertyr‚   rY   rO   Úsetterr    r¡   r¨   r³   r´   r¶   rº   r®   rÁ   rÄ   rÇ   r!   r!   r!   r"   r%   1   sZ    	




)






&r%   c                       s@   e Zd ZdZddhZ‡ fdd„Z‡ fdd„Zedd	„ ƒZ‡  Z	S )
r;   ÚHTTP_rJ   rª   c                    s<   i }|  ¡ D ]\}}|  |¡}|r|||< qtƒ  |¡ d S r:   )ÚitemsÚparse_header_nameÚsuperr6   )r5   Úenvironr<   r’   r   Úname©r8   r!   r"   r6   «  s   
€zHttpHeaders.__init__c                    s   t ƒ  | dd¡¡S )z:Allow header lookup using underscores in place of hyphens.r•   ú-)rÍ   Ú__getitem__Úreplace©r5   r|   rÐ   r!   r"   rÒ   ³  ó   zHttpHeaders.__getitem__c                 C   s>   |  | j¡r|t| jƒd … }n|| jvrd S | dd¡ ¡ S )Nr•   rÑ   )r„   ÚHTTP_PREFIXÚlenÚUNPREFIXED_HEADERSrÓ   Útitle)Úclsr’   r!   r!   r"   rÌ   ·  s
   
zHttpHeaders.parse_header_name)
r   r   r    rÖ   rØ   r6   rÒ   ÚclassmethodrÌ   Ú__classcell__r!   r!   rÐ   r"   r;   ¦  s    r;   c                       sì   e Zd ZdZdZdZd)‡ fdd„	Zed*dd	„ƒZe	d
d„ ƒZ
e
jdd„ ƒZ
dd„ Z‡ fdd„Z‡ fdd„Zdd„ Zdd„ Z‡ fdd„Zd+‡ fdd„	Z‡ fdd„Z‡ fdd„Z‡ fdd „Z‡ fd!d"„Zd+‡ fd#d$„	Zd%d&„ Zd+d'd(„Z‡  ZS ),r(   aû  
    A specialized MultiValueDict which represents a query string.

    A QueryDict can be used to represent GET or POST data. It subclasses
    MultiValueDict since keys in such data can be repeated, for instance
    in the data from a form with a <select multiple> field.

    By default QueryDicts are immutable, though the copy() method
    will always return a mutable copy.

    Both keys and values set on this class are converted from the given encoding
    (DEFAULT_CHARSET by default) to str.
    TNFc              
      s¾   t ƒ  ¡  |p	tj| _|pd}d| jtjdœ}t|tƒr3z| | j¡}W n t	y2   | d¡}Y nw zt
|fi |¤ŽD ]
\}}|  ||¡ q<W n tyY } ztdƒ|‚d }~ww || _d S )Nr'   T)Úkeep_blank_valuesrO   Úmax_num_fieldsz
iso-8859-1zRThe number of GET/POST parameters exceeded settings.DATA_UPLOAD_MAX_NUMBER_FIELDS.)rÍ   r6   r	   ÚDEFAULT_CHARSETrO   ÚDATA_UPLOAD_MAX_NUMBER_FIELDSÚ
isinstanceÚbytesÚdecodeÚUnicodeDecodeErrorr   Ú
appendlistr�   r   Ú_mutable)r5   Úquery_stringr&   rO   Úparse_qsl_kwargsr|   r   r²   rÐ   r!   r"   r6   Ô  s4   
ý
þÿÿý€û
	zQueryDict.__init__r'   c                 C   s2   | dd|d�}|D ]}|  ||¡ q	|sd|_|S )zt
        Return a new QueryDict with keys (may be repeated) from an iterable and
        values from value.
        r'   T©r&   rO   F)rå   ræ   )rÚ   Úiterabler   r&   rO   Úqr|   r!   r!   r"   Úfromkeysò  s   zQueryDict.fromkeysc                 C   s   | j d u r	tj| _ | j S r:   )r—   r	   rß   r4   r!   r!   r"   rO   ÿ  s   
zQueryDict.encodingc                 C   s
   || _ d S r:   r–   )r5   r   r!   r!   r"   rO     r=   c                 C   s   | j stdƒ‚d S )Nz$This QueryDict instance is immutable)ræ   r£   r4   r!   r!   r"   Ú_assert_mutable	  s   ÿzQueryDict._assert_mutablec                    ó2   |   ¡  t|| jƒ}t|| jƒ}tƒ  ||¡ d S r:   )rí   Úbytes_to_textrO   rÍ   Ú__setitem__©r5   r|   r   rÐ   r!   r"   rð     ó   zQueryDict.__setitem__c                    s   |   ¡  tƒ  |¡ d S r:   )rí   rÍ   Ú__delitem__rÔ   rÐ   r!   r"   ró     s   zQueryDict.__delitem__c                 C   s4   | j dd| jd�}|  ¡ D ]
\}}| ||¡ q|S ©Nr'   Tré   )r8   rO   r¹   Úsetlist)r5   Úresultr|   r   r!   r!   r"   Ú__copy__  s   zQueryDict.__copy__c                 C   sP   | j dd| jd�}||t| ƒ< |  ¡ D ]\}}| t ||¡t ||¡¡ q|S rô   )r8   rO   Úidr¹   rõ   ÚcopyÚdeepcopy)r5   Úmemorö   r|   r   r!   r!   r"   Ú__deepcopy__  s
   zQueryDict.__deepcopy__c                    s8   ˆ   ¡  t|ˆ jƒ}‡ fdd„|D ƒ}tƒ  ||¡ d S )Nc                    s   g | ]}t |ˆ jƒ‘qS r!   )rï   rO   )rC   Úeltr4   r!   r"   r�   '  s    z%QueryDict.setlist.<locals>.<listcomp>)rí   rï   rO   rÍ   rõ   )r5   r|   r·   rÐ   r4   r"   rõ   $  s   zQueryDict.setlistc                    s   |   ¡  tƒ  ||¡S r:   )rí   rÍ   Úsetlistdefault)r5   r|   Údefault_listrÐ   r!   r"   rþ   *  ó   zQueryDict.setlistdefaultc                    rî   r:   )rí   rï   rO   rÍ   rå   rñ   rÐ   r!   r"   rå   .  rò   zQueryDict.appendlistc                    s   |   ¡  tƒ j|g|¢R Ž S r:   )rí   rÍ   Úpop)r5   r|   r°   rÐ   r!   r"   r  4  s   zQueryDict.popc                    s   |   ¡  tƒ  ¡ S r:   )rí   rÍ   Úpopitemr4   rÐ   r!   r"   r  8  s   
zQueryDict.popitemc                    s   |   ¡  tƒ  ¡  d S r:   )rí   rÍ   Úclearr4   rÐ   r!   r"   r  <  r   zQueryDict.clearc                    s.   |   ¡  t|| jƒ}t|| jƒ}tƒ  ||¡S r:   )rí   rï   rO   rÍ   Ú
setdefault)r5   r|   r}   rÐ   r!   r"   r  @  s   zQueryDict.setdefaultc                 C   s
   |   i ¡S )z%Return a mutable copy of this object.)rü   r4   r!   r!   r"   rù   F  r=   zQueryDict.copyc                    sb   g }ˆrˆ  ˆj¡‰‡fdd„‰ ndd„ ‰ ˆ ¡ D ]\‰}| ‡ ‡‡fdd„|D ƒ¡ qd |¡S )ah  
        Return an encoded string of all query string arguments.

        `safe` specifies characters which don't require quoting, for example::

            >>> q = QueryDict(mutable=True)
            >>> q['next'] = '/a&b/'
            >>> q.urlencode()
            'next=%2Fa%26b%2F'
            >>> q.urlencode(safe='/')
            'next=/a%26b/'
        c                    s   dt | ˆ ƒt |ˆ ƒf S )Nz%s=%s)r   ©ÚkÚv)Úsafer!   r"   Úencode[  s   z#QueryDict.urlencode.<locals>.encodec                 S   s   t | |iƒS r:   )r   r  r!   r!   r"   r	  `  rÅ   c                 3   s.   � | ]}ˆ ˆ  ˆj¡t|ƒ  ˆj¡ƒV  qd S r:   )r	  rO   ri   )rC   r  )r	  r  r5   r!   r"   rG   d  s
   € ÿ
ÿz&QueryDict.urlencode.<locals>.<genexpr>ú&)r	  rO   r¹   ÚextendÚjoin)r5   r  Úoutputr·   r!   )r	  r  r  r5   r"   r   J  s   
þ
zQueryDict.urlencode)NFN)r'   FNr:   )r   r   r    r$   ræ   r—   r6   rÛ   rì   rÈ   rO   rÉ   rí   rð   ró   r÷   rü   rõ   rþ   rå   r  r  r  r  rù   r   rÜ   r!   r!   rÐ   r"   r(   À  s2    

r(   c                   @   s8   e Zd Zdd„ Zdd„ Zdd„ Zedd„ ƒZd	d
„ ZdS )Ú	MediaTypec                 C   s4   t |r| d¡ndƒ\}| _| d¡\| _}| _d S )NÚasciirÂ   rq   )r   r	  ÚparamsÚ	partitionÚ	main_typeÚsub_type)r5   Úmedia_type_raw_lineÚ	full_typer•   r!   r!   r"   r6   l  s   
ÿzMediaType.__init__c                 C   s@   d  dd„ | j ¡ D ƒ¡}d| j| jrd| j |f S d|f S )Nr'   c                 s   s&   � | ]\}}d ||  d¡f V  qdS )z; %s=%sr  N)rã   )rC   r  r  r!   r!   r"   rG   s  s   € 
ÿz$MediaType.__str__.<locals>.<genexpr>rp   z/%s)r  r  rË   r  r  )r5   Ú
params_strr!   r!   r"   Ú__str__r  s   
ÿýýzMediaType.__str__c                 C   s   d| j j| f S )Nz<%s: %s>)r8   r    r4   r!   r!   r"   r9   |  s   zMediaType.__repr__c                 C   s   | j dko	| jdkS )NÚ*)r  r  r4   r!   r!   r"   Úis_all_types  rÕ   zMediaType.is_all_typesc                 C   s6   | j rdS t|ƒ}| j|jkr| jd|jhv rdS dS )NTr  F)r  r  r  r  )r5   Úotherr!   r!   r"   rB   ƒ  s   zMediaType.matchN)	r   r   r    r6   r  r9   rÈ   r  rB   r!   r!   r!   r"   r  k  s    

r  c                 C   s   t | tƒrt| |dƒS | S )u×   
    Convert bytes objects to strings, using the given encoding. Illegally
    encoded input characters are replaced with Unicode "unknown" codepoint
    (ï¿½).

    Return any non-bytes objects without change.
    rÓ   )rá   râ   ri   )ÚsrO   r!   r!   r"   rï   �  s   
rï   c                 C   sx   |   ¡ } t | ¡sdS | d dkr| dfS |  dd¡}t|ƒdkr#|n|d df\}}| d	¡r6|d
d… n|}||fS )z”
    Return a (domain, port) tuple from a given host.

    Returned domain is lowercased. If the host is invalid, the domain will be
    empty.
    )r'   r'   éÿÿÿÿú]r'   ú:r   r�   r   Ú.N)ÚlowerÚhost_validation_rerB   Úrsplitr×   rt   )rZ   r‡   rb   rc   r!   r!   r"   r_   �  s   
 r_   c                    s   t ‡ fdd„|D ƒƒS )a4  
    Validate the given host for this site.

    Check that the host looks valid and matches a host or host pattern in the
    given list of ``allowed_hosts``. Any pattern beginning with a period
    matches a domain and all its subdomains (e.g. ``.example.com`` matches
    ``example.com`` and any subdomain), ``*`` matches anything, and anything
    else must match exactly.

    Note: This function assumes that the given host is lowercased and has
    already had the port, if any, stripped off.

    Return ``True`` for a valid host, ``False`` otherwise.
    c                 3   s"   � | ]}|d kpt ˆ |ƒV  qdS )r  N)r   )rC   Úpattern©rZ   r!   r"   rG   Â  s   € 
ÿz validate_host.<locals>.<genexpr>)rH   )rZ   ra   r!   r$  r"   r`   ³  s   ÿr`   c                 C   s   dd„ |   d¡D ƒS )Nc                 S   s   g | ]
}|  ¡ rt|ƒ‘qS r!   )r‘   r  )rC   Útokenr!   r!   r"   r�   È  s    z'parse_accept_header.<locals>.<listcomp>rŒ   )r�   )r’   r!   r!   r"   r?   Ç  s   r?   )9rL   rù   Úior   Ú	itertoolsr   Úurllib.parser   r   r   r   r   Údjango.confr	   Údjango.corer
   Údjango.core.exceptionsr   r   r   r   Údjango.core.filesr   Údjango.http.multipartparserr   r   Údjango.utils.datastructuresr   r   r   Údjango.utils.encodingr   r   Údjango.utils.functionalr   Údjango.utils.httpr   r   Údjango.utils.regex_helperr   Úmultipartparserr   Úobjectrx   r!  r¯   r   Ú	Exceptionr#   r%   r;   r(   r  rï   r_   r`   r?   r!   r!   r!   r"   Ú<module>   sB    ÿ
  w ,$