o
    Mf+                     @   s  d dl m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 ejd  dk rd dlmZ e	fZ
eZd dlmZ d dlZd dlZd dlmZmZmZmZmZ d dlmZmZmZmZmZm Z m!Z! dd	 Zd dl"Z"d d
l"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ erd dl"m,Z, d dl-Z-d dl.Z.d dl/Z0d dl1m1Z1 d dl2Z2e3Z3d dl4m5Z6 d dl4m7Z8 nd dl9mZ e:fZ
e:Zd dl9m;Z d dlZd dlZd dl<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m'Z'm(Z(m)Z)m*Z*m+Z+ erd dl>m,Z, d dl?m&Z&m%Z%m Z  d dl@mAZ- d dl>mBZ" d dlCmAZ. d dl0Z0d dlDm1Z1 d dlEmFZ2 eGZ3d dl4m8Z8 e6Z6z
d dlmHZHmIZI W n ey\   G dd deJZId`ddZKdd ZHY nw zd dlmLZM W n eyw   G dd deNZMY nw zd dl<mOZO W n ey   ejPejQB dfd d!ZOY nw d d"lRmSZT eUeTd#reTZSnd d$lRmVZW G d%d& d&eWZVG d'd( d(eTZSzd d)lXmYZY W n ey   d*d+ ZYY nw d dl<Z<d dlZZZze[Z[W n e\y   d d,l]m^Z^ d-d. Z[Y nw zej_Z_ej`Z`W n# eay   eb p	d/Zcecd0krd1Zdnd2Zdd3d4 Z_d5d6 Z`Y nw zd d7lemfZf W n# eyJ   d d8lgmhZhmiZi d dlZejd9Zkd:d; Zld<d= ZfY nw zd d>lmmnZn W n eyc   d d>lomnZn Y nw ejdd? d@k rse1 jpZpnd dAlmmpZp zd dBlqmrZr W n0 ey   d dClqmsZs zd dDltmuZv W n ey   dadFdGZvY nw G dHdI dIesZrY nw zd dJlwmxZx W n ey   dbdKdLZxY nw zd dMlqmyZy W nB ey   zd dNlzm{Z| W n ey   d dNl}m{Z| Y nw zd dOl~mZmZmZ W n
 ey	   Y nw G dPdQ dQeZyY nw zd dRlmZmZ W dS  ey[   ejdSejZdTdU ZG dVdW dWeZdbdXdYZG dZd[ d[eZG d\d] d]eZG d^d_ d_eNZY dS w )c    )absolute_importN   )StringIO)FileType)urlparse
urlunparseurljoinurlsplit
urlunsplit)urlretrievequoteunquoteurl2pathnamepathname2urlContentTooShortError	splittypec                 C   s   t | tr
| d} t| S )Nutf-8)
isinstanceunicodeencode_quote)s r   \/var/www/html/analyze/labelStudio/lib/python3.10/site-packages/pip/_vendor/distlib/compat.pyr      s   

r   )	RequesturlopenURLError	HTTPErrorHTTPBasicAuthHandlerHTTPPasswordMgrHTTPHandlerHTTPRedirectHandlerbuild_opener)HTTPSHandler)
HTMLParser)ifilter)ifilterfalse)TextIOWrapper)r   r   r   r   r   r	   r
   r   )
r   r   r   r   r   r   r   r    r!   r"   )r   r   r   )filterfalse)match_hostnameCertificateErrorc                   @   s   e Zd ZdS )r*   N)__name__
__module____qualname__r   r   r   r   r*   _   s    r*      c           
      C   s   g }| sdS |  d}|d |dd }}|d}||kr'tdt|  |s1|  | kS |dkr;|d n|d	sE|d	rN|t| n|t|	d
d |D ]
}|t| q\t
dd| d tj}	|	|S )zpMatching according to RFC 6125, section 6.4.3

        http://tools.ietf.org/html/rfc6125#section-6.4.3
        F.r   r.   N*z,too many wildcards in certificate DNS name: z[^.]+zxn--z\*z[^.]*z\Az\.z\Z)splitcountr*   reprlowerappend
startswithreescapereplacecompilejoin
IGNORECASEmatch)
dnhostnamemax_wildcardspatspartsleftmost	remainder	wildcardsfragpatr   r   r   _dnsname_matchc   s*   



rH   c                 C   s   | st dg }| dd}|D ]\}}|dkr%t||r  dS || q|sJ| ddD ]}|D ]\}}|dkrHt||rC  dS || q2q.t|dkr^td	|d
tt|f t|dkrntd||d f td)a=  Verify that *cert* (in decoded format as returned by
        SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
        rules are followed, but IP addresses are not accepted for *hostname*.

        CertificateError is raised on failure. On success, the function
        returns nothing.
        ztempty or no certificate, match_hostname needs a SSL socket or SSL context with either CERT_OPTIONAL or CERT_REQUIREDsubjectAltNamer   DNSNsubject
commonNamer.   z&hostname %r doesn't match either of %s, zhostname %r doesn't match %rr   z=no appropriate commonName or subjectAltName fields were found)	
ValueErrorgetrH   r5   lenr*   r;   mapr3   )certr?   dnsnamessankeyvaluesubr   r   r   r)      s8   




r)   )SimpleNamespacec                   @      e Zd ZdZdd ZdS )	ContainerzR
        A generic container for when multiple values need to be returned
        c                 K   s   | j | d S N__dict__update)selfkwargsr   r   r   __init__   s   zContainer.__init__N)r+   r,   r-   __doc__ra   r   r   r   r   rZ      s    rZ   )whichc                    s"  dd }t j r| |r S dS |du rt jdt j}|s#dS |t j}tj	dkr^t j
|vr:|dt j
 t jddt j}t fd	d
|D rT g}n fdd|D }n g}t }|D ](}t j|}||vr|| |D ]}	t j||	}
||
|r|
    S qyqfdS )aK  Given a command, mode, and a PATH string, return the path which
        conforms to the given mode on the PATH, or None if there is no such
        file.

        `mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result
        of os.environ.get("PATH"), or can be overridden with a custom search
        path.

        c                 S   s&   t j| ot | |ot j|  S r[   )ospathexistsaccessisdir)fnmoder   r   r   _access_check   s   zwhich.<locals>._access_checkNPATHwin32r   PATHEXT c                 3   s"    | ]}   |  V  qd S r[   )r4   endswith.0extcmdr   r   	<genexpr>   s     zwhich.<locals>.<genexpr>c                    s   g | ]} | qS r   r   rq   rt   r   r   
<listcomp>       zwhich.<locals>.<listcomp>)rd   re   dirnameenvironrO   defpathr1   pathsepsysplatformcurdirinsertanysetnormcaseaddr;   )ru   rj   re   rk   pathextfilesseendirnormdirthefilenamer   rt   r   rc      s<   




rc   )ZipFile	__enter__)
ZipExtFilec                   @   $   e Zd Zdd Zdd Zdd ZdS )r   c                 C   s   | j |j  d S r[   r\   )r_   baser   r   r   ra        zZipExtFile.__init__c                 C      | S r[   r   r_   r   r   r   r        zZipExtFile.__enter__c                 G      |    d S r[   closer_   exc_infor   r   r   __exit__     zZipExtFile.__exit__N)r+   r,   r-   ra   r   r   r   r   r   r   r     s    r   c                   @   r   )r   c                 C   r   r[   r   r   r   r   r   r   #  r   zZipFile.__enter__c                 G   r   r[   r   r   r   r   r   r   &  r   zZipFile.__exit__c                 O   s    t j| g|R i |}t|S r[   )BaseZipFileopenr   )r_   argsr`   r   r   r   r   r   *  s   zZipFile.openN)r+   r,   r-   r   r   r   r   r   r   r   r   "  s    r   )python_implementationc                   C   s0   dt jv rdS tjdkrdS t jdrdS dS )z6Return a string identifying the Python implementation.PyPyjavaJython
IronPythonCPython)r}   versionrd   r   r6   r   r   r   r   r   1  s   

r   )Callablec                 C   s
   t | tS r[   )r   r   )objr   r   r   callableC     
r   r   mbcsstrictsurrogateescapec                 C   6   t | tr| S t | tr| ttS tdt| j Nzexpect bytes or str, not %s)	r   bytes	text_typer   _fsencoding	_fserrors	TypeErrortyper+   filenamer   r   r   fsencodeW     

r   c                 C   r   r   )	r   r   r   decoder   r   r   r   r+   r   r   r   r   fsdecode`  r   r   )detect_encoding)BOM_UTF8lookupzcoding[:=]\s*([-\w.]+)c                 C   sH   | dd   dd}|dks|drdS |dv s |dr"d	S | S )
z(Imitates get_normal_name in tokenizer.c.N   _-r   zutf-8-)zlatin-1
iso-8859-1ziso-latin-1)zlatin-1-ziso-8859-1-ziso-latin-1-r   )r4   r9   r6   )orig_encencr   r   r   _get_normal_nameq  s   r   c                    s   zj jW n ty   dY nw d d}d}fdd} fdd}| }|tr7d |d	d }d
}|s=|g fS ||}|rH||gfS | }|sR||gfS ||}|r^|||gfS |||gfS )a?  
        The detect_encoding() function is used to detect the encoding that should
        be used to decode a Python source file.  It requires one argument, readline,
        in the same way as the tokenize() generator.

        It will call readline a maximum of twice, and return the encoding used
        (as a string) and a list of any lines (left as bytes) it has read in.

        It detects the encoding from the presence of a utf-8 bom or an encoding
        cookie as specified in pep-0263.  If both a bom and a cookie are present,
        but disagree, a SyntaxError will be raised.  If the encoding cookie is an
        invalid charset, raise a SyntaxError.  Note that if a utf-8 bom is found,
        'utf-8-sig' is returned.

        If no encoding is specified, then the default of 'utf-8' will be returned.
        NFr   c                      s   z  W S  t y   Y dS w )N    )StopIterationr   )readliner   r   read_or_stop  s
   z%detect_encoding.<locals>.read_or_stopc                    s   z|  d}W n ty   d}d urd|}t|w t|}|s(d S t|d }zt|}W n tyQ   d u rGd| }t|d|}t|w  rp|j	dkrld u rcd}t|d}t||d	7 }|S )
Nr   z'invalid or missing encoding declarationz{} for {!r}r   zunknown encoding: zunknown encoding for {!r}: {}zencoding problem: utf-8z encoding problem for {!r}: utf-8z-sig)
r   UnicodeDecodeErrorformatSyntaxError	cookie_refindallr   r   LookupErrorr   )lineline_stringmsgmatchesencodingcodec)	bom_foundr   r   r   find_cookie  s@   
	

z$detect_encoding.<locals>.find_cookieTr   z	utf-8-sig)__self__r   AttributeErrorr6   r   )r   r   defaultr   r   firstsecondr   )r   r   r   r   r   |  s6   &


r   )r8      )r      )unescape)ChainMap)MutableMapping)recursive_repr...c                    s    fdd}|S )zm
            Decorator to make a repr function return fillvalue for a recursive
            call
            c                    sL   t    fdd}td|_td|_td|_tdi |_|S )Nc              	      sJ   t | t f}|v r S | z| }W | |S | w r[   )id	get_identr   discard)r_   rU   result)	fillvaluerepr_runninguser_functionr   r   wrapper  s   


z=_recursive_repr.<locals>.decorating_function.<locals>.wrapperr,   rb   r+   __annotations__)r   getattrr,   rb   r+   r   )r   r   r   )r   r   r   decorating_function  s   z,_recursive_repr.<locals>.decorating_functionr   )r   r   r   r   r   _recursive_repr  s   r   c                   @   s   e Zd ZdZdd Zdd Zdd Zd'd	d
Zdd Zdd Z	dd Z
dd Ze dd Zedd Zdd ZeZdd Zedd Zdd Zdd  Zd!d" Zd#d$ Zd%d& ZdS )(r   a   A ChainMap groups multiple dicts (or other mappings) together
        to create a single, updateable view.

        The underlying mappings are stored in a list.  That list is public and can
        accessed or updated using the *maps* attribute.  There is no other state.

        Lookups search the underlying mappings successively until a key is found.
        In contrast, writes, updates, and deletions only operate on the first
        mapping.

        c                 G   s   t |pi g| _dS )zInitialize a ChainMap by setting *maps* to the given mappings.
            If no mappings are provided, a single empty dictionary is used.

            N)listmaps)r_   r   r   r   r   ra     s   zChainMap.__init__c                 C   s   t |r[   )KeyErrorr_   rU   r   r   r   __missing__  s   zChainMap.__missing__c              	   C   s6   | j D ]}z|| W   S  ty   Y qw | |S r[   )r   r   r   )r_   rU   mappingr   r   r   __getitem__  s   

zChainMap.__getitem__Nc                 C   s   || v r| | S |S r[   r   r_   rU   r   r   r   r   rO   $  s   zChainMap.getc                 C      t t j| j S r[   )rP   r   unionr   r   r   r   r   __len__'  r   zChainMap.__len__c                 C   r   r[   )iterr   r   r   r   r   r   r   __iter__*  r   zChainMap.__iter__c                    s   t  fdd| jD S )Nc                 3   s    | ]} |v V  qd S r[   r   )rr   mrU   r   r   rv   .  s    z(ChainMap.__contains__.<locals>.<genexpr>r   r   r   r   r   r   __contains__-  s   zChainMap.__contains__c                 C   s
   t | jS r[   r   r   r   r   r   __bool__0  r   zChainMap.__bool__c                 C   s   d | dtt| jS )Nz{0.__class__.__name__}({1})rM   )r   r;   rQ   r3   r   r   r   r   r   __repr__3  s   zChainMap.__repr__c                 G   s   | t j|g|R  S )z?Create a ChainMap with a single dict created from the iterable.)dictfromkeys)clsiterabler   r   r   r   r  8  s   zChainMap.fromkeysc                 C   s&   | j | jd  g| jdd R  S )zHNew ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]r   r.   N)	__class__r   copyr   r   r   r   r  =  s   &zChainMap.copyc                 C   s   | j i g| jR  S )z;New ChainMap with a new dict followed by all previous maps.r  r   r   r   r   r   	new_childC  s   zChainMap.new_childc                 C   s   | j | jdd  S )zNew ChainMap from maps[1:].r.   Nr	  r   r   r   r   parentsG  s   zChainMap.parentsc                 C   s   || j d |< d S )Nr   )r   )r_   rU   rV   r   r   r   __setitem__L  r   zChainMap.__setitem__c                 C   s0   z	| j d |= W d S  ty   td|w )Nr   (Key not found in the first mapping: {!r})r   r   r   r   r   r   r   __delitem__O  s
   zChainMap.__delitem__c                 C   s(   z| j d  W S  ty   tdw )zPRemove and return an item pair from maps[0]. Raise KeyError is maps[0] is empty.r   z#No keys found in the first mapping.)r   popitemr   r   r   r   r   r  U  s
   zChainMap.popitemc                 G   s8   z| j d j|g|R  W S  ty   td|w )zWRemove *key* from maps[0] and return its value. Raise KeyError if *key* not in maps[0].r   r  )r   popr   r   )r_   rU   r   r   r   r   r  \  s
   zChainMap.popc                 C   s   | j d   dS )z'Clear maps[0], leaving maps[1:] intact.r   N)r   clearr   r   r   r   r  c     zChainMap.clearr[   )r+   r,   r-   rb   ra   r   r   rO   r   r   r   r  r   r  classmethodr  r  __copy__r
  propertyr  r  r  r  r  r  r   r   r   r   r     s0    



r   )cache_from_sourcec                 C   s6   |  dsJ |d u rd}|rd}| | S d}| | S )Nz.pyTco)rp   )re   debug_overridesuffixr   r   r   r  j  s   r  )OrderedDict)r   )KeysView
ValuesView	ItemsViewc                   @   s   e Zd ZdZdd ZejfddZejfddZdd	 Zd
d Z	dd Z
d6ddZdd Zdd Zdd Zdd Zdd Zdd Zdd ZeZe Zefdd Zd7d"d#Zd7d$d%Zd&d' Zd(d) Zed7d*d+Zd,d- Zd.d/ Zd0d1 Zd2d3 Z d4d5 Z!d!S )8r  z)Dictionary that remembers insertion orderc                 O   sp   t |dkrtdt | z| j W n ty-   g  | _}||dg|dd< i | _Y nw | j|i | dS )zInitialize an ordered dictionary.  Signature is the same as for
            regular dictionaries, but keyword arguments are not recommended
            because their insertion order is arbitrary.

            r.   z$expected at most 1 arguments, got %dN)rP   r   _OrderedDict__rootr   _OrderedDict__map_OrderedDict__update)r_   r   kwdsrootr   r   r   ra     s   


zOrderedDict.__init__c                 C   sF   || vr| j }|d }|||g |d<  |d< | j|< || || dS )z!od.__setitem__(i, y) <==> od[i]=yr   r.   N)r  r   )r_   rU   rV   dict_setitemr#  lastr   r   r   r    s
    zOrderedDict.__setitem__c                 C   s0   || | | j |\}}}||d< ||d< dS )z od.__delitem__(y) <==> del od[y]r.   r   N)r   r  )r_   rU   dict_delitem	link_prev	link_nextr   r   r   r    s   
zOrderedDict.__delitem__c                 c   :    | j }|d }||ur|d V  |d }||usdS dS )zod.__iter__() <==> iter(od)r.   r   Nr  r_   r#  currr   r   r   r        
zOrderedDict.__iter__c                 c   r)  )z#od.__reversed__() <==> reversed(od)r   r   Nr*  r+  r   r   r   __reversed__  r-  zOrderedDict.__reversed__c                 C   sb   z | j  D ]}|dd= q| j}||dg|dd< | j   W n	 ty)   Y nw t|  dS )z.od.clear() -> None.  Remove all items from od.N)r   
itervaluesr  r  r   r  )r_   noder#  r   r   r   r    s   zOrderedDict.clearTc                 C   s|   | st d| j}|r|d }|d }||d< ||d< n|d }|d }||d< ||d< |d }| j|= t| |}||fS )zod.popitem() -> (k, v), return and remove a (key, value) pair.
            Pairs are returned in LIFO order if last is true or FIFO order if false.

            zdictionary is emptyr   r.   r   )r   r  r   r  r  )r_   r%  r#  linkr'  r(  rU   rV   r   r   r   r    s    
zOrderedDict.popitemc                 C      t | S )zod.keys() -> list of keys in od)r   r   r   r   r   keys     zOrderedDict.keysc                        fdd D S )z#od.values() -> list of values in odc                    s   g | ]} | qS r   r   rr   rU   r   r   r   rw     rx   z&OrderedDict.values.<locals>.<listcomp>r   r   r   r   r   values  r  zOrderedDict.valuesc                    r5  )z.od.items() -> list of (key, value) pairs in odc                    s   g | ]}| | fqS r   r   r6  r   r   r   rw         z%OrderedDict.items.<locals>.<listcomp>r   r   r   r   r   items  r  zOrderedDict.itemsc                 C   r2  )z0od.iterkeys() -> an iterator over the keys in od)r   r   r   r   r   iterkeys  r4  zOrderedDict.iterkeysc                 c   s    | D ]}| | V  qdS )z2od.itervalues -> an iterator over the values in odNr   r_   kr   r   r   r/    s   zOrderedDict.itervaluesc                 c   s    | D ]	}|| | fV  qdS )z=od.iteritems -> an iterator over the (key, value) items in odNr   r;  r   r   r   	iteritems  s   zOrderedDict.iteritemsc                  O   s   t | dkrtdt | f | std| d }d}t | dkr%| d }t|tr6|D ]}|| ||< q,nt|drI| D ]}|| ||< q?n|D ]\}}|||< qK| D ]\}}|||< qXdS )	a  od.update(E, **F) -> None.  Update od from dict/iterable E and F.

            If E is a dict instance, does:           for k in E: od[k] = E[k]
            If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
            Or if E is an iterable of items, does:   for k, v in E: od[k] = v
            In either case, this is followed by:     for k, v in F.items(): od[k] = v

            r   z8update() takes at most 2 positional arguments (%d given)z,update() takes at least 1 argument (0 given)r   r   r.   r3  N)rP   r   r   r  hasattrr3  r9  )r   r"  r_   otherrU   rV   r   r   r   r^     s.   	



zOrderedDict.updatec                 C   s0   || v r| | }| |= |S || j u rt||S )zod.pop(k[,d]) -> v, remove specified key and return the corresponding value.
            If key is not found, d is returned if given, otherwise KeyError is raised.

            )_OrderedDict__markerr   )r_   rU   r   r   r   r   r   r  &  s   
zOrderedDict.popNc                 C   s   || v r| | S || |< |S )zDod.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in odr   r   r   r   r   
setdefault3  s   zOrderedDict.setdefaultc                 C   sj   |si }t | t f}||v rdS d||< z| s#d| jjf W ||= S d| jj|  f W ||= S ||= w )zod.__repr__() <==> repr(od)r   r.   z%s()z%s(%r))r   
_get_identr  r+   r9  )r_   _repr_runningcall_keyr   r   r   r  :  s   zOrderedDict.__repr__c                    sX    fdd D }t   }t t D ]}||d q|r& j|f|fS  j|ffS )z%Return state information for picklingc                    s   g | ]}| | gqS r   r   rr   r<  r   r   r   rw   J  r8  z*OrderedDict.__reduce__.<locals>.<listcomp>N)varsr  r  r  r  )r_   r9  	inst_dictr<  r   r   r   
__reduce__H  s   zOrderedDict.__reduce__c                 C   s
   |  | S )z!od.copy() -> a shallow copy of od)r  r   r   r   r   r  R     
zOrderedDict.copyc                 C   s   |  }|D ]}|||< q|S )zOD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
            and values equal to v (which defaults to None).

            r   )r  r  rV   drU   r   r   r   r  V  s   
zOrderedDict.fromkeysc                 C   s6   t |trt| t|ko|  | kS t| |S )zod.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
            while comparison to a regular mapping is order-insensitive.

            )r   r  rP   r9  r  __eq__r_   r?  r   r   r   rK  a  s   
 zOrderedDict.__eq__c                 C   s
   | |k S r[   r   rL  r   r   r   __ne__j  r   zOrderedDict.__ne__c                 C   r2  )z@od.viewkeys() -> a set-like object providing a view on od's keys)r  r   r   r   r   viewkeyso  r4  zOrderedDict.viewkeysc                 C   r2  )z<od.viewvalues() -> an object providing a view on od's values)r  r   r   r   r   
viewvaluess  r4  zOrderedDict.viewvaluesc                 C   r2  )zBod.viewitems() -> a set-like object providing a view on od's items)r  r   r   r   r   	viewitemsw  r4  zOrderedDict.viewitems)Tr[   )"r+   r,   r-   rb   ra   r  r  r  r   r.  r  r  r3  r7  r9  r:  r/  r=  r^   r!  objectr@  r  rA  r  rH  r  r  r  rK  rM  rN  rO  rP  r   r   r   r   r    s<    
	




	r  )BaseConfiguratorvalid_identz^[a-z_][a-z0-9_]*$c                 C   s   t | }|std|  dS )Nz!Not a valid Python identifier: %rT)
IDENTIFIERr=   rN   )r   r   r   r   r   rS    s   
rS  c                   @   s"   e Zd ZdZdd ZdddZdS )ConvertingDictz A converting dictionary wrapper.c                 C   J   t | |}| j|}||ur#|| |< t|tttfv r#| |_||_	|S r[   )
r  r   configuratorconvertr   rU  ConvertingListConvertingTupleparentrU   r_   rU   rV   r   r   r   r   r        
zConvertingDict.__getitem__Nc                 C   sL   t | ||}| j|}||ur$|| |< t|tttfv r$| |_||_	|S r[   )
r  rO   rW  rX  r   rU  rY  rZ  r[  rU   r_   rU   r   rV   r   r   r   r   rO     s   
zConvertingDict.getr[   )r+   r,   r-   rb   r   rO   r   r   r   r   rU    s    rU  c                 C   sD   t | ||}| j|}||ur t|tttfv r | |_||_	|S r[   )
r  r  rW  rX  r   rU  rY  rZ  r[  rU   r^  r   r   r   r    s   
r  c                   @   s"   e Zd ZdZdd ZdddZdS )	rY  zA converting list wrapper.c                 C   rV  r[   )
r   r   rW  rX  r   rU  rY  rZ  r[  rU   r\  r   r   r   r     r]  zConvertingList.__getitem__c                 C   s<   t | |}| j|}||urt|tttfv r| |_|S r[   )	r   r  rW  rX  r   rU  rY  rZ  r[  )r_   idxrV   r   r   r   r   r    s   
zConvertingList.popN)r_  )r+   r,   r-   rb   r   r  r   r   r   r   rY    s    rY  c                   @   rY   )rZ  zA converting tuple wrapper.c                 C   sB   t | |}| j|}||urt|tttfv r| |_||_	|S r[   )
tupler   rW  rX  r   rU  rY  rZ  r[  rU   r\  r   r   r   r     s   
zConvertingTuple.__getitem__N)r+   r,   r-   rb   r   r   r   r   r   rZ    s    rZ  c                   @   s   e Zd ZdZedZedZedZedZ	edZ
ddd	ZeeZd
d Zdd Zdd Zdd Zdd Zdd Zdd ZdS )rR  zQ
        The configurator base class which defines some useful defaults.
        z%^(?P<prefix>[a-z]+)://(?P<suffix>.*)$z^\s*(\w+)\s*z^\.\s*(\w+)\s*z^\[\s*(\w+)\s*\]\s*z^\d+$ext_convertcfg_convert)rs   cfgc                 C   s   t || _| | j_d S r[   )rU  configrW  )r_   re  r   r   r   ra     s   
zBaseConfigurator.__init__c           	   	   C   s   | d}|d}z-| |}|D ]"}|d| 7 }zt||}W q ty4   | | t||}Y qw |W S  tyY   t dd \}}td||f }|||_	|_
|w )zl
            Resolve strings to objects using standard import and attribute
            syntax.
            r/   r   r.   NzCannot resolve %r: %s)r1   r  importerr   r   ImportErrorr}   r   rN   	__cause____traceback__)	r_   r   r   usedfoundrF   etbvr   r   r   resolve  s&   



zBaseConfigurator.resolvec                 C   s
   |  |S )z*Default converter for the ext:// protocol.)ro  r_   rV   r   r   r   rb    rI  zBaseConfigurator.ext_convertc                 C   s   |}| j |}|du rtd| || d }| j| d  }|r|| j|}|r6|| d  }n1| j|}|rg| d }| j|sO|| }nz
t	|}|| }W n t
yf   || }Y nw |rr|| d }ntd||f |s%|S )z*Default converter for the cfg:// protocol.NzUnable to convert %rr   zUnable to convert %r at %r)WORD_PATTERNr=   rN   endre  groupsDOT_PATTERNINDEX_PATTERNDIGIT_PATTERNintr   )r_   rV   restr   rJ  r`  nr   r   r   rc    s8   
zBaseConfigurator.cfg_convertc                 C   s   t |tst |trt|}| |_|S t |ts&t |tr&t|}| |_|S t |ts9t |tr9t|}| |_|S t |trd| j	
|}|rd| }|d }| j|d}|rd|d }t| |}||}|S )z
            Convert values to an appropriate type. dicts, lists and tuples are
            replaced by their converting alternatives. Strings are checked to
            see if they have a conversion format and are converted if they do.
            prefixNr  )r   rU  r  rW  rY  r   rZ  ra  string_typesCONVERT_PATTERNr=   	groupdictvalue_convertersrO   r   )r_   rV   r   rJ  rz  	converterr  r   r   r   rX  .  s2   


zBaseConfigurator.convertc                    sr     d}t|s| |}  dd}t fdd D }|di |}|r7| D ]
\}}t||| q,|S )z1Configure an object with a user-supplied factory.z()r/   Nc                    s    g | ]}t |r| | fqS r   )rS  rE  re  r   r   rw   Q  s     z5BaseConfigurator.configure_custom.<locals>.<listcomp>r   )r  r   ro  r  r9  setattr)r_   re  r  propsr`   r   r   rV   r   r  r   configure_customJ  s   

z!BaseConfigurator.configure_customc                 C   s   t |tr	t|}|S )z0Utility function which converts lists to tuples.)r   r   ra  rp  r   r   r   as_tupleX  s   
zBaseConfigurator.as_tupleN)r+   r,   r-   rb   r7   r:   r|  rq  rt  ru  rv  r~  staticmethod
__import__rf  ra   ro  rb  rc  rX  r  r  r   r   r   r   rR    s$    




"rR  )r.   )r   r[   )
__future__r   rd   r7   r}   sslrg  version_infor   
basestringr{  r   r   typesr   	file_type__builtin__builtinsConfigParserconfigparserr   r   r   r	   r
   urllibr   r   r   r   r   r   r   r   urllib2r   r   r   r   r   r   r    r!   r"   r#   httplib	xmlrpclibQueuequeuer$   htmlentitydefs	raw_input	itertoolsr%   filterr&   r(   iostrr'   shutilurllib.parseurllib.requesturllib.errorhttp.clientclientrequestxmlrpc.clienthtml.parserhtml.entitiesentitiesinputr)   r*   rN   rH   rX   rZ   rQ  rc   F_OKX_OKzipfiler   r   r>  r   BaseZipExtFiler~   r   	sysconfigr   	NameErrorcollections.abcr   r   r   r   getfilesystemencodingr   r   tokenizer   codecsr   r   r:   r   r   htmlr8   cgir   collectionsr   r   reprlibr   r   importlib.utilr  r  threadr   rB  dummy_thread_abcollr  r  r  r  logging.configrR  rS  IrT  rU  r  r   rY  ra  rZ  r   r   r   r   <module>   sB  $,(0
2b	C

	
l
   

