a
    &ñ»j‰d  ã                   @  sâ   d dl mZ d dlZd dlZd dlmZmZ d dlmZm	Z	m
Z
mZmZmZmZmZ d dlmZmZmZmZmZ d dlZddlmZmZmZ ddlmZmZmZ dd	lm Z  d
Z!G dd„ deƒZ"G dd„ dƒZ#G dd„ de#ƒZ$dS )é    )ÚannotationsN)ÚMappingÚMutableMapping)ÚAnyÚDictÚ	ItemsViewÚIteratorÚKeysViewÚOptionalÚUnionÚ
ValuesView)ÚParseResultÚquoteÚunquoteÚ	urlencodeÚurlparseé   )Ú
ProxyErrorÚURLErrorÚURLParamsError)ÚURL_ALLOWED_PARAMSÚURLParamTypesÚURLTypes)Úto_str)ÚURLÚ	URLParamsÚProxyc                   @  s*  e Zd ZdZd;ddœdd„Zeddœd	d
„ƒZd<ddddœdd„Zddœdd„Zddœdd„Z	ddœdd„Z
d dœdd„Zdd„ Zdd„ Zddd œd!d"„Zdddd#œd$d%„Zddd œd&d'„Zddd œd(d)„Zd*dœd+d,„Zd-dœd.d/„Zd-dœd0d1„Zddœd2d3„Zd=ddd4dœd5d6„Zd7d8œd9d:„ZdS )>r   aü  
    A mapping-like object for managing URL query parameters.

    This class provides a dictionary-like interface for URL parameters,
    handling the normalization of keys and values into the correct string format
    and encoding them into a query string. It supports multi-value parameters.

    Attributes:
        params (str): The URL-encoded query string representation of the parameters.

    Examples:
        >>> params = URLParams({'key1': 'value1', 'key2': ['value2', 'value3']})
        >>> print(str(params))
        'key1=value1&key2=value2&key2=value3'

        >>> params.update({'key3': 4, 'active': True})
        >>> print(params)
        'key1=value1&key2=value2&key2=value3&key3=4&active=true'

        >>> 'key1' in params
        True
    NzOptional[URLParamTypes])Úparamsc                 K  s   | j |fi |¤Ž| _dS )am  
        Initializes the URLParams object.

        Args:
            params: A dictionary, another URLParams instance, or a list of tuples
                    to initialize the parameters.
            **kwargs: Additional key-value pairs to add or overwrite parameters.

        Raises:
            URLParamsError: If `params` is not a valid mapping type.
        N)Ú_prepareÚ_data©Úselfr   Úkwargs© r#   ú>E:\soccer\ml_env\Lib\site-packages\tls_requests/models/urls.pyÚ__init__.   s    zURLParams.__init__Ústr©Úreturnc                 C  s   t | ƒS )z5Returns the encoded URL parameters as a query string.)r&   ©r!   r#   r#   r$   r   <   s    zURLParams.paramsr   ÚNone)r   r"   r(   c                 K  s   | j  | j|fi |¤Ž¡ dS )zé
        Updates the current parameters with new ones from a mapping or keyword args.

        Args:
            params: A dictionary-like object of parameters to add.
            **kwargs: Additional key-value pairs to add.
        N)r   Úupdater   r    r#   r#   r$   r+   A   s    zURLParams.updater	   c                 C  s
   | j  ¡ S )z%Returns a view of the parameter keys.)r   Úkeysr)   r#   r#   r$   r,   K   s    zURLParams.keysr   c                 C  s
   | j  ¡ S )z'Returns a view of the parameter values.)r   Úvaluesr)   r#   r#   r$   r-   O   s    zURLParams.valuesr   c                 C  s
   | j  ¡ S )z0Returns a view of the parameter key-value pairs.)r   Úitemsr)   r#   r#   r$   r.   S   s    zURLParams.itemsc                 C  s   |   | j ¡ ¡S )z/Returns a shallow copy of the current instance.)Ú	__class__r   Úcopyr)   r#   r#   r$   r0   W   s    zURLParams.copyc                 C  s   t | jdd�S )z@Returns the URL-encoded string representation of the parameters.T)Údoseq)r   r   r)   r#   r#   r$   Ú__str__[   s    zURLParams.__str__c                 C  s   d| j j|  ¡ f S )z9Returns the official string representation of the object.ú<%s: %s>)r/   Ú__name__r.   r)   r#   r#   r$   Ú__repr___   s    zURLParams.__repr__Úbool)Úkeyr(   c                 C  s
   || j v S )z)Checks if a key exists in the parameters.©r   ©r!   r7   r#   r#   r$   Ú__contains__c   s    zURLParams.__contains__)r7   Úvaluer(   c                 C  s   || j |< dS )z7Sets a parameter key-value pair, normalizing the input.Nr8   )r!   r7   r;   r#   r#   r$   Ú__setitem__g   s    zURLParams.__setitem__c                 C  s
   | j | S )zRetrieves a parameter value.r8   r9   r#   r#   r$   Ú__getitem__k   s    zURLParams.__getitem__c                 C  s   | j |= dS )zDeletes a parameter key.Nr8   r9   r#   r#   r$   Ú__delitem__o   s    zURLParams.__delitem__r   c                 C  s
   t | jƒS )z,Returns an iterator over the parameter keys.)Úiterr   r)   r#   r#   r$   Ú__iter__s   s    zURLParams.__iter__Úintc                 C  s
   t | jƒS )z!Returns the number of parameters.)Úlenr   r)   r#   r#   r$   Ú__len__w   s    zURLParams.__len__c                 C  s   t t| ƒƒS )z1Returns the hash of the encoded parameter string.)Úhashr&   r)   r#   r#   r$   Ú__hash__{   s    zURLParams.__hash__c                 C  s6   t || jƒs&t |tƒr"|  |¡}ndS t| j|jkƒS )z:Checks for equality based on the encoded parameter string.F)Ú
isinstancer/   r   r6   r   )r!   Úotherr#   r#   r$   Ú__eq__   s
    
zURLParams.__eq__zDict[str, Any]c                   sº   |du ri }n6t |ˆ jƒr(t| ¡ ƒ}nt |tƒr<t|ƒ}ntdƒ‚| |¡ i }| ¡ D ]Z\}}t |ttfƒsxtdƒ‚t |t	t
tfƒrœ‡ fdd„|D ƒ}n
ˆ  |¡}||ˆ  |¡< qZ|S )aa  
        Normalizes and prepares the input parameters.

        Args:
            params: A dictionary-like object of parameters.
            **kwargs: Additional keyword arguments.

        Returns:
            A dictionary with normalized keys and values.

        Raises:
            URLParamsError: If keys or values are of an invalid type.
        NzInvalid parameters.zInvalid parameters key type.c                   s   g | ]}ˆ   |¡‘qS r#   )Ú	normalize)Ú.0Úsr)   r#   r$   Ú
<listcomp>¦   ó    z&URLParams._prepare.<locals>.<listcomp>)rF   r/   Údictr.   r   r   r+   r&   ÚbytesÚlistÚtupleÚsetrI   )r!   r   r"   ÚpreparedÚresultÚkÚvr#   r)   r$   r   ˆ   s"    



zURLParams._preparer   )rK   c                 C  sN   t |tttttfƒstdƒ‚t |tƒr2t|ƒ ¡ S t |tƒrF| d¡S t|ƒS )a  
        Converts a supported type into a string.

        Args:
            s: The value to normalize (str, bytes, int, float, bool).

        Returns:
            The normalized string value.

        Raises:
            URLParamsError: If the value type is not supported.
        zInvalid parameters value type.úutf-8)	rF   r&   rO   rA   Úfloatr6   r   ÚlowerÚdecode)r!   rK   r#   r#   r$   rI   ­   s    


zURLParams.normalize)N)N)N)r4   Ú
__module__Ú__qualname__Ú__doc__r%   Úpropertyr   r+   r,   r-   r.   r0   r2   r5   r:   r<   r=   r>   r@   rC   rE   rH   r   rI   r#   r#   r#   r$   r      s*   
	%r   c                   @  sÂ   e Zd ZdZdZd%dddœdd„Zed	d
„ ƒZejdd
„ ƒZedd„ ƒZ	e	jdd„ ƒZ	eddœdd„ƒZ
eddœdd„ƒZeddœdd„ƒZdd„ Zdd„ Zdddœdd„Zd&d!dd"œd#d$„ZdS )'r   as  
    A class for parsing, manipulating, and constructing URLs.

    This class provides a structured way to interact with URL components,
    integrating with `URLParams` for easy query string management. It handles
    IDNA encoding for hostnames and ensures proper URL construction.

    Attributes:
        url (str): The full URL string. Can be set to re-parse.
        params (URLParams): An object managing the URL's query parameters.
        parsed (ParseResult): The result from `urllib.parse.urlparse`.
        scheme (str): The URL scheme (e.g., "https").
        netloc (str): The network location part (e.g., "user:pass@host:port").
        host (str): The hostname, IDNA-encoded.
        port (str): The port number as a string, if present.
        path (str): The hierarchical path.
        query (str): The complete query string, combining original and added params.
        fragment (str): The fragment identifier.
        username (str): The username for authentication.
        password (str): The password for authentication.
        auth (tuple): A (username, password) tuple.

    Examples:
        >>> url = URL("https://example.com/path?q=1#fragment", params={"key": "value"})
        >>> print(url.scheme)
        'https'
        >>> print(url.host)
        'example.com'
        >>> print(url.query)
        'q=1&key=value'

        >>> url.params.update({'key2': 'value2'})
        >>> print(unquote(url.url))
        'https://example.com/path?q=1&key=value&key2=value2#fragment'

        >>> url.url = 'https://httpbin.org/get'
        >>> print(unquote(url.url))
        'https://httpbin.org/get?key=value&key2=value2'
    )ÚauthÚschemeÚhostÚportÚpathÚfragmentÚusernameÚpasswordNr   r   )Úurlr   c                 K  s    |   |¡| _d| _t|ƒ| _dS )aQ  
        Initializes the URL object.

        Args:
            url: The URL string, bytes, or another URL object.
            params: A dictionary-like object to be used as query parameters.
            **kwargs: Additional keyword arguments for URLParams.

        Raises:
            URLError: If the provided URL is invalid.
        N)r   Ú_parsedÚ_urlr   Ú_params)r!   rg   r   r"   r#   r#   r$   r%   ú   s    zURL.__init__c                 C  s   | j du r|  d¡| _ | j S )z#The full, reconstructed URL string.NF)ri   Ú_buildr)   r#   r#   r$   rg   
  s    
zURL.urlc                 C  s   |   |¡| _|  d¡| _dS )z/Allows setting a new URL, which will be parsed.FN)r   rh   rk   ri   ©r!   r;   r#   r#   r$   rg     s    c                 C  s   | j S )z5The `URLParams` object for managing query parameters.)rj   r)   r#   r#   r$   r     s    z
URL.paramsc                 C  s   d| _ t|ƒ| _dS )zSets a new `URLParams` object.N)ri   r   rj   rl   r#   r#   r$   r     s    r   r'   c                 C  s   | j S )z3The `ParseResult` object from the standard library.)rh   r)   r#   r#   r$   Úparsed"  s    z
URL.parsedr&   c                 C  sD   | j }d|v r*| d¡r"| d¡s*d| }| jr@d || jg¡S |S )z.The network location, including host and port.ú:ú[ú]z[%s])ra   Ú
startswithÚendswithrb   Újoin)r!   ra   r#   r#   r$   Únetloc'  s    z
URL.netlocc                 C  sV   d}| j jr0| jjr0d t| j jƒ| jjg¡}n"| jjrB| jj}n| j jrR| j j}|S )zAThe combined query string from the original URL and the `params`.Ú ú&)rm   Úqueryr   rs   r   )r!   rw   r#   r#   r$   rw   /  s    
z	URL.queryc                 C  s   |   ¡ S )z3Returns the full URL string with the real password.)rk   r)   r#   r#   r$   r2   ;  s    zURL.__str__c                 C  s   d| j jt|  d¡ƒf S )z<Returns a representation of the URL with a secured password.r3   T)r/   r4   r   rk   r)   r#   r#   r$   r5   ?  s    zURL.__repr__úUnion['URL', str, bytes]©rg   r(   c                 C  sb  t |tƒr| d¡}n"t || jƒs0t| j|jƒr8t|ƒ}t |tƒsPtd|› �ƒ‚| ¡ }d|vr’| d¡s’| d¡s’| d¡s’| d¡s’d|› �}d	|v �ròd|v rÚ| 	dd
¡d
  	dd
¡d  	dd
¡d  	dd
¡d }n(| 	dd
¡d  	dd
¡d  	dd
¡d }| 
dd
¡d }| d	¡d
k�rò| d¡�r8d|v �sòg }| d	¡\}}}| ¡ �rt| d	¡d
k�rt| ||f¡ | |df¡ |D ]j\}	}
zDt |	¡ d|	› d�}|
�rº|d	|
› �7 }| ||d
¡}W  �qòW n t�yì   Y �q†Y n0 �q†| jD ]}t| |dƒ �qøzìd}d|v �r:| 	dd
¡d
  	dd
¡d }n| 	dd
¡d }d|v �s^d|v �rî| d¡d
k�s~| d¡d
k�r†tdƒ‚| d¡}| d¡}||k�r¬tdƒ‚||d
 |… }zt |¡ W n" t�yì   td|› �ƒ‚Y n0 t|ƒ}W nD ttf�y< } z&td|› dt|ƒ› �ƒ|‚W Y d}~n
d}~0 0 |j|jf| _|j| _|j�p^d ¡ }|�srd| _nfzt |¡ || _W nP t�yÖ   zt  !|¡ d¡| _W n$ t j"�yÐ   td|› �ƒ‚Y n0 Y n0 d| _#z|j#�rôt|j#ƒ| _#W n: t�y0 } z t|j$d › d�ƒ‚W Y d}~n
d}~0 0 |j%| _%|j&| _&|j�pLd| _|j�pZd| _|S )zò
        Validates, decodes, and parses the input URL.

        Args:
            url: The URL to prepare.

        Returns:
            A `ParseResult` object.

        Raises:
            URLError: For invalid URL types or formats.
        rW   zInvalid URL: ú://ú/z./ú?ú#úhttp://rn   é   r   ú@éÿÿÿÿro   rp   ru   NzMalformed bracketed hostzInvalid bracket orderzInvalid IPv6 in brackets: z. ÚasciizInvalid IDNA hostname: z. port range must be 0 - 65535.)'rF   rO   rZ   r/   Ú
issubclassr&   r   Úlstriprq   ÚsplitÚrsplitÚcountÚ
rpartitionÚisdigitÚappendÚ	ipaddressÚIPv6AddressÚreplaceÚ
ValueErrorÚ	__attrs__ÚsetattrÚfindr   ÚAttributeErrorre   rf   r_   r`   ÚhostnamerY   ra   Ú
ip_addressÚidnaÚencodeÚ	IDNAErrorrb   Úargsrc   rd   )r!   rg   Zurl_to_parseZauthority_candidateZhost_candidateZpossible_ipsZh_pÚ_rb   ÚipZp_valZrepairedÚattrÚ	authorityÚstartÚendZ
ip_contentrm   Úer“   r#   r#   r$   r   C  sš    



6(&


 


0

*zURL._prepareFr6   ©Úsecurer(   c                 C  s¾   | j pd}|r|dgng }| j}| js,| jrb| jp4d}| jp>d}|rHd}d d ||g¡| jg¡}| |¡ | jptd}| jr”| d || jg¡¡ n
| |¡ | jr´| d| j ¡ d |¡S )zÂ
        Constructs the URL string from its components.

        Args:
            secure: If True, masks the password in the output.

        Returns:
            The final URL string.
        ru   rz   ú[secure]r€   rn   r|   r}   )	r`   rt   re   rf   rs   rŠ   rc   rw   rd   )r!   r¡   r`   Úurlsrœ   re   rf   rc   r#   r#   r$   rk   Â  s*    



þÿ


z
URL._build)N)F)r4   r[   r\   r]   r�   r%   r^   rg   Úsetterr   rm   rt   rw   r2   r5   r   rk   r#   r#   r#   r$   r   Æ   s*   (



r   c                
      sð   e Zd ZdZdZd4ddddddœdddd	d
d
ddœ‡ fdd„Zdd„ Zeddœdd„ƒZej	dddœdd„ƒZdddœ‡ fdd„Z
d5dddœd d!„Zd"d#„ Zd$d%„ Zd6d
d&œd'd(„Zd)d*„ Zed+d,d-œd.d/„ƒZed7ddd,d1œd2d3„ƒZ‡  ZS )8r   a=  
    A specialized URL class for managing proxy configurations and performance.

    This class inherits from `URL` and extends it with features for proxy
    rotation strategies, such as weighting, success/failure tracking, and
    metadata. It restricts the allowed URL schemes to those common for proxies.

    Attributes:
        ALLOWED_SCHEMES (tuple): Allowed proxy schemes ('http', 'https', 'socks5', 'socks5h').
        weight (float): The weight of the proxy, used in selection algorithms.
        region (Optional[str]): A geographical or logical region identifier.
        latency (Optional[float]): The last recorded latency in seconds.
        success_rate (Optional[float]): A score indicating reliability (0.0 to 1.0).
        meta (Dict[str, Any]): A dictionary for arbitrary user-defined data.
        failures (int): A counter for consecutive connection failures.
        last_used (Optional[float]): A timestamp of the last time the proxy was used.

    Examples:
        >>> proxy = Proxy("http://user:pass@127.0.0.1:8080", weight=5.0, region="us-east")
        >>> proxy.mark_failed()
        >>> print(proxy.failures)
        1
        >>> print(proxy.weight)
        4.25
        >>> proxy.mark_success()
        >>> data = proxy.to_dict()
        >>> print(data['url'])
        'http://user:pass@127.0.0.1:8080'
    )ÚhttpÚhttpsZsocks5Zsocks5hNç      ð?)ÚweightÚregionÚlatencyÚsuccess_rateÚmetar   r   rX   zOptional[str]zOptional[float]zOptional[Dict[str, Any]])rg   r   r¨   r©   rª   r«   r¬   c          	        sJ   |pd| _ || _|| _|| _|p"i | _d| _d| _tƒ j|fi |¤Ž dS )aÐ  
        Initializes the Proxy object.

        Args:
            url: The proxy URL string, bytes, or another URL object.
            params: URL parameters (rarely used for proxies).
            weight: The initial weight for proxy selection (higher is more likely).
            region: An identifier for the proxy's region.
            latency: The initial or last known latency in seconds.
            success_rate: A score from 0.0 to 1.0 indicating reliability.
            meta: A dictionary for storing arbitrary user data.
            **kwargs: Additional keyword arguments passed to the parent `URL` class.

        Raises:
            ProxyError: If the URL is invalid or the scheme is not supported.
        r§   r   N)	Ú_weightr©   rª   r«   r¬   ÚfailuresÚ	last_usedÚsuperr%   )	r!   rg   r   r¨   r©   rª   r«   r¬   r"   ©r/   r#   r$   r%   
  s    

zProxy.__init__c                 C  s$   d| j jt|  d¡ƒt| ddƒf S )z=Returns a secure representation of the proxy with its weight.z<%s: %s, weight=%s>Tr¨   Zunset)r/   r4   r   rk   Úgetattrr)   r#   r#   r$   r5   /  s
    
ýzProxy.__repr__r'   c                 C  s
   | j pdS )Nr§   )r­   r)   r#   r#   r$   r¨   7  s    zProxy.weightr*   )r¨   r(   c                 C  s.   zt |ƒ| _W n ty(   tdƒ‚Y n0 d S )Nz#Weight must be an integer or float.)rX   r­   rŽ   r   )r!   r¨   r#   r#   r$   r¨   ;  s    rx   r   ry   c                   sÎ   z¤t |tƒr| d¡}nt|ƒ}| ¡ }d|vr:d|› �}tt| ƒ |¡}t|jƒ 	¡ | j
vrptd|j› d�ƒ‚ttt|jƒƒd tt|jƒƒ ƒ}d| _d| _|W S  tyÈ   tdt|ƒ› �ƒ‚Y n0 dS )	a‹  
        Parses the proxy URL, ensuring it has a valid scheme and format.

        Overrides the parent `_prepare` to enforce proxy-specific rules.

        Args:
            url: The proxy URL to prepare.

        Returns:
            A `ParseResult` object containing only scheme and netloc.

        Raises:
            ProxyError: If the URL is invalid or the scheme is not allowed.
        rW   rz   r~   zInvalid proxy scheme `zB`. The allowed schemes are ('http', 'https', 'socks5', 'socks5h').ru   zInvalid proxy: N)rF   rO   rZ   r&   Ústripr°   r   r   r`   rY   ÚALLOWED_SCHEMESr   r   r   rt   rc   rd   r   )r!   rg   Zurl_strrm   r±   r#   r$   r   B  s$    

ÿ$zProxy._prepareFr6   r&   r    c                 C  s^   | j pddg}| j}| js | jrJd | j| jg¡}|r:d}d || jg¡}| |¡ d |¡S )zó
        Constructs the proxy URL string.

        Overrides the parent `_build` to exclude path, query, and fragment.

        Args:
            secure: If True, masks the password.

        Returns:
            The proxy URL string.
        r¥   rz   rn   r¢   r€   ru   )r`   rt   re   rf   rs   rŠ   )r!   r¡   r£   rœ   Úuserinfor#   r#   r$   rk   j  s    þÿ
zProxy._buildc                 C  s   t   ¡ | _dS )z3Sets the `last_used` timestamp to the current time.N)Útimer¯   r)   r#   r#   r$   Ú	mark_used‡  s    zProxy.mark_usedc                 C  s$   |  j d7  _ td| jd ƒ| _dS )z
        Records a connection failure.

        Increments the failure count and applies a decay factor to the weight.
        r   gš™™™™™¹?g333333ë?N)r®   Úmaxr¨   r)   r#   r#   r$   Úmark_failed‹  s    zProxy.mark_failed)rª   c                 C  sF   |r
|| _ td| jd ƒ| _| jp$dd d | _td| jd ƒ| _dS )	zæ
        Records a connection success.

        Resets failure count, updates latency, and improves success rate and weight.

        Args:
            latency: The observed connection latency in seconds for this success.
        r   r   r§   gffffffî?gš™™™™™©?g      $@gÍÌÌÌÌÌð?N)rª   r¸   r®   r«   Úminr¨   )r!   rª   r#   r#   r$   Úmark_success”  s
    	zProxy.mark_successc                 C  s   | j | j| j| j| j| jdœS )zž
        Serializes the proxy's state to a dictionary.

        Returns:
            A dictionary containing the proxy's URL and performance metrics.
        ©rg   r¨   r©   rª   r«   r¯   r¼   r)   r#   r#   r$   Úto_dict¤  s    úzProxy.to_dictzdict[str, Any]z'Proxy')Údatar(   c                 C  s,   d|vrt dƒ‚| d¡}| f d|i|¤ŽS )ab  
        Creates a Proxy object from a dictionary.

        Args:
            data: A dictionary containing a 'url' key and other optional
                  proxy attributes (`weight`, `region`, etc.).

        Returns:
            A new `Proxy` instance.

        Raises:
            ProxyError: If the 'url' key is missing from the dictionary.
        rg   zUMissing required key: 'url'. The proxy configuration dictionary must include a 'url'.)r   Úpop)Úclsr¾   rg   r#   r#   r$   Ú	from_dict´  s    
ÿþzProxy.from_dictú|)ÚrawÚ	separatorr(   c                 C  sª   |  ¡ }|stdƒ‚dd„ | |¡D ƒ}|d }d}d}t|ƒdkrp|d rpzt|d ƒ}W n tyn   Y n0 t|ƒd	krŒ|d rŒ|d }d
|vrœd| }| |||d�S )a  
        Parses a proxy from a string with optional attributes.

        Handles various common formats for representing proxies in text files.
        Comments (#) and blank lines should be handled by the calling code.

        Supported Formats:
          - `http://user:pass@host:port`
          - `socks5://host:port`
          - `host:port` (defaults to http)
          - `host:port|weight`
          - `host:port|weight|region`
          - `http://user:pass@host:port|weight|region`

        Args:
            raw: The raw proxy string.
            separator: The character used to separate attributes (default: '|').

        Returns:
            A new `Proxy` instance.

        Raises:
            ProxyError: If the proxy string is empty or malformed.
        zEmpty proxy string.c                 S  s   g | ]}|  ¡ ‘qS r#   )r³   )rJ   Úpr#   r#   r$   rL   ê  rM   z%Proxy.from_string.<locals>.<listcomp>r   r§   Nr   r   é   rz   r~   )r¨   r©   )r³   r   r…   rB   rX   Ú	Exception)rÀ   rÃ   rÄ   Úpartsrg   r¨   r©   r#   r#   r$   Úfrom_stringÌ  s"    zProxy.from_string)N)F)N)rÂ   )r4   r[   r\   r]   r´   r%   r5   r^   r¨   r¤   r   rk   r·   r¹   r»   r½   ÚclassmethodrÁ   rÉ   Ú__classcell__r#   r#   r±   r$   r   é  s2    ý÷"%(	r   )%Ú
__future__r   r‹   r¶   Úcollections.abcr   r   Útypingr   r   r   r   r	   r
   r   r   Úurllib.parser   r   r   r   r   r•   Ú
exceptionsr   r   r   Útypesr   r   r   Úutilsr   Ú__all__r   r   r   r#   r#   r#   r$   Ú<module>   s    ( 1  %