3
g                 @   s*  d dl mZ d dlZd dlZd dlZyd dlZW n ek
rH   dZY nX ejd  dk rrd 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 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r&d dl$m.Z. d dl/Z/d dl0Z0d dl1Z2d dl3m3Z3 d dl4Z4e5Z5d dl6m7Z8 d dl6m9Z: nd 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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lAjBZ/d dl?jCZ$d dlDjBZ0d dl2Z2d dlEm3Z3 d dlFjGZ4eHZ5d dl6m:Z: e8Z8yd dlmIZImJZJ W n8 ek
r   G dd deKZJdbddZLdd ZIY nX yd dlmMZN W n& ek
r   G dd deOZNY nX yd d lmPZP W n, ek
r<   ejQejRB dfd!d"ZPY nX d d#lSmTZU eVeUd$r\eUZTn,d d%lSmWZX G d&d' d'eXZWG d(d) d)eUZTyd d*lYmZZZ W n ek
r   d+d, ZZY nX yd dl[Z[W n" ek
r   dd-lm[Z[ Y nX ye\Z\W n* e]k
r   d d.l^m_Z_ d/d0 Z\Y nX yej`Z`ejaZaW nH ebk
rt   ejc pJd1Zdedd2kr\d3Zend4Zed5d6 Z`d7d8 ZaY nX yd d9lfmgZg W nH ek
r   d d:lhmiZimjZj d dlZejkd;Zld<d= Zmd>d? ZgY nX yd d@lnmoZo W n" ek
r   d d@lpmoZo Y nX ejddA dck r"e3 jqZqnd dClnmqZq yd dDlrmsZs W nd ek
r   d dElrmtZt yd dFlumvZw W n  ek
r   dddHdIZwY nX G dJdK dKetZsY nX yd dLlxmyZy W nH ek
r   yd dLlzmyZy W n  ek
r   dedMdNZyY nX Y nX yd dOlrm{Z{ W n ek
r   yd dPl|m}Z~ W n" ek
rR   d dPlm}Z~ Y nX yd dQlmZmZmZ W n ek
r   Y nX G dRdS dSeZ{Y nX yd dTlmZmZ W nv ek
r$   ejkdUejZdVdW ZG dXdY dYeZdfdZd[ZG d\d] d]eZG d^d_ d_eZG d`da daeOZY nX dS )g    )absolute_importN   )StringIO)FileType   )shutil)urlparse
urlunparseurljoinurlsplit
urlunsplit)urlretrievequoteunquoteurl2pathnamepathname2urlContentTooShortError	splittypec             C   s   t | tr| jd} t| S )Nzutf-8)
isinstanceunicodeencode_quote)s r   X/var/www/tester-filtro-web/env/lib/python3.6/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 | j d}|d |dd  }}|jd}||krNtdt|  |sb| j |j kS |dkrv|jd n>|jd	s|jd	r|jtj| n|jtj|j	d
d x|D ]}|jtj| qW tj
ddj| d tj}	|	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_matchd   s(    


rH   c             C   s   | st dg }| jdf }x0|D ](\}}|dkr"t||r@dS |j| q"W |sxF| jdf D ]6}x0|D ](\}}|dkrjt||rdS |j| qjW q`W t|dkrtd|d	jtt|f n*t|dkrtd
||d f ntddS )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subjectAltNameDNSNsubject
commonNamer   z&hostname %r doesn't match either of %sz, 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*      s.    

r*   )SimpleNamespacec               @   s   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 j| d S )N)__dict__update)selfkwargsr   r   r   __init__   s    zContainer.__init__N)r,   r-   r.   __doc__r]   r   r   r   r   rX      s   rX   )whichc                s"  dd }t jj r&| |r" S dS |dkr>t jjdt j}|sFdS |jt j}tj	dkrt j
|krt|jdt j
 t jjddjt j}t fd	d
|D r g}q fdd|D }n g}t }xT|D ]L}t jj|}||kr|j| x(|D ] }	t jj||	}
||
|r|
S qW qW d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j| o$t j| |o$t jj|  S )N)ospathexistsaccessisdir)fnmoder   r   r   _access_check   s    zwhich.<locals>._access_checkNPATHwin32r   PATHEXT c             3   s    | ]} j  j|j  V  qd S )N)r4   endswith).0ext)cmdr   r   	<genexpr>   s    zwhich.<locals>.<genexpr>c                s   g | ]} | qS r   r   )rm   rn   )ro   r   r   
<listcomp>   s    zwhich.<locals>.<listcomp>)r`   ra   dirnameenvironrN   defpathr1   pathsepsysplatformcurdirinsertanysetnormcaseaddr;   )ro   rf   ra   rg   pathextfilesseendirnormdirthefilenamer   )ro   r   r_      s8    






r_   )ZipFile	__enter__)
ZipExtFilec               @   s$   e Zd Zdd Zdd Zdd ZdS )r   c             C   s   | j j|j  d S )N)rY   rZ   )r[   baser   r   r   r]     s    zZipExtFile.__init__c             C   s   | S )Nr   )r[   r   r   r   r     s    zZipExtFile.__enter__c             G   s   | j   d S )N)close)r[   exc_infor   r   r   __exit__  s    zZipExtFile.__exit__N)r,   r-   r.   r]   r   r   r   r   r   r   r     s   r   c               @   s$   e Zd Zdd Zdd Zdd ZdS )r   c             C   s   | S )Nr   )r[   r   r   r   r   $  s    zZipFile.__enter__c             G   s   | j   d S )N)r   )r[   r   r   r   r   r   '  s    zZipFile.__exit__c             O   s   t j| f||}t|S )N)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krdS tjdkrdS t jjdr,dS dS )z6Return a string identifying the Python implementation.PyPyjavaJython
IronPythonCPython)rv   versionr`   r   r6   r   r   r   r   r   2  s    

r   )	sysconfig)Callablec             C   s
   t | tS )N)r   r   )objr   r   r   callableF  s    r   zutf-8mbcsstrictsurrogateescapec             C   s:   t | tr| S t | tr$| jttS tdt| j d S )Nzexpect bytes or str, not %s)	r   bytes	text_typer   _fsencoding	_fserrors	TypeErrortyper,   )filenamer   r   r   fsencodeZ  s    

r   c             C   s:   t | tr| S t | tr$| jttS tdt| j d S )Nzexpect bytes or str, not %s)	r   r   r   decoder   r   r   r   r,   )r   r   r   r   fsdecodec  s    

r   )detect_encoding)BOM_UTF8lookupzcoding[:=]\s*([-\w.]+)c             C   sH   | dd j  jdd}|dks*|jdr.dS |dks@|jdrDdS | S )z(Imitates get_normal_name in tokenizer.c.N   _-zutf-8zutf-8-latin-1
iso-8859-1iso-latin-1latin-1-iso-8859-1-iso-latin-1-)r   r   r   )r   r   r   )r4   r9   r6   )orig_encencr   r   r   _get_normal_namet  s    
r   c                s   yj jW n tk
r$   dY nX d d}d}fdd} fdd}| }|jtrpd |d	d }d
}|s||g fS ||}|r||gfS | }|s||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.
        NFzutf-8c                  s    y  S  t k
r   dS X d S )N    )StopIterationr   )readliner   r   read_or_stop  s    z%detect_encoding.<locals>.read_or_stopc                s   y| j d}W n4 tk
rB   d}d k	r6dj|}t|Y nX tj|}|sVd S t|d }yt|}W n: tk
r   d krd| }ndj|}t|Y nX  r|j	dkr؈d krd}n
dj}t||d	7 }|S )
Nzutf-8z'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  s6    



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     s4    
&


r   )r8         )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                sB   t | t f}|kr S j| z| }W d j| X |S )N)id	get_identr}   discard)r[   rT   result)	fillvaluerepr_runninguser_functionr   r   wrapper  s    
z=_recursive_repr.<locals>.decorating_function.<locals>.wrapperr-   r^   r,   __annotations__)r{   getattrr-   r^   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   r]     s    zChainMap.__init__c             C   s   t |d S )N)KeyError)r[   rT   r   r   r   __missing__  s    zChainMap.__missing__c             C   s8   x,| j D ]"}y|| S  tk
r(   Y qX qW | j|S )N)r   r   r   )r[   rT   mappingr   r   r   __getitem__  s    
zChainMap.__getitem__Nc             C   s   || kr| | S |S )Nr   )r[   rT   r   r   r   r   rN   '  s    zChainMap.getc             C   s   t t j| j S )N)rO   r{   unionr   )r[   r   r   r   __len__*  s    zChainMap.__len__c             C   s   t t j| j S )N)iterr{   r   r   )r[   r   r   r   __iter__-  s    zChainMap.__iter__c                s   t  fdd| jD S )Nc             3   s   | ]} |kV  qd S )Nr   )rm   m)rT   r   r   rp   1  s    z(ChainMap.__contains__.<locals>.<genexpr>)rz   r   )r[   rT   r   )rT   r   __contains__0  s    zChainMap.__contains__c             C   s
   t | jS )N)rz   r   )r[   r   r   r   __bool__3  s    zChainMap.__bool__c             C   s   dj | djtt| jS )Nz{0.__class__.__name__}({1})z, )r   r;   rP   r3   r   )r[   r   r   r   __repr__6  s    zChainMap.__repr__c             G   s   | t j|f| S )z?Create a ChainMap with a single dict created from the iterable.)dictfromkeys)clsiterabler   r   r   r   r   ;  s    zChainMap.fromkeysc             C   s$   | j | jd j f| jdd  S )zHNew ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]r   r   N)	__class__r   copy)r[   r   r   r   r   @  s    zChainMap.copyc             C   s   | j i f| j S )z;New ChainMap with a new dict followed by all previous maps.)r   r   )r[   r   r   r   	new_childF  s    zChainMap.new_childc             C   s   | j | jdd  S )zNew ChainMap from maps[1:].r   N)r   r   )r[   r   r   r   parentsJ  s    zChainMap.parentsc             C   s   || j d |< d S )Nr   )r   )r[   rT   rU   r   r   r   __setitem__O  s    zChainMap.__setitem__c             C   s8   y| j d |= W n" tk
r2   tdj|Y nX d S )Nr   z(Key not found in the first mapping: {!r})r   r   r   )r[   rT   r   r   r   __delitem__R  s    zChainMap.__delitem__c             C   s0   y| j d j S  tk
r*   tdY nX dS )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.N)r   popitemr   )r[   r   r   r   r   X  s    zChainMap.popitemc             G   s>   y| j d j|f| S  tk
r8   tdj|Y nX dS )zWRemove *key* from maps[0] and return its value. Raise KeyError if *key* not in maps[0].r   z(Key not found in the first mapping: {!r}N)r   popr   r   )r[   rT   r   r   r   r   r   _  s    zChainMap.popc             C   s   | j d j  dS )z'Clear maps[0], leaving maps[1:] intact.r   N)r   clear)r[   r   r   r   r   f  s    zChainMap.clear)N)r,   r-   r.   r^   r]   r   r   rN   r   r   r   r   r   r   classmethodr   r   __copy__r   propertyr   r   r   r   r   r   r   r   r   r   r     s(   
r   )cache_from_sourcec             C   s0   | j dst|d krd}|r$d}nd}| | S )Nz.pyTco)rl   AssertionError)ra   debug_overridesuffixr   r   r   r   p  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d8d$d%Zd&d' Zd(d) Zed9d*d+Zd,d- Zd.d/ Zd0d1 Zd2d3 Z d4d5 Z!d!S ):r  z)Dictionary that remembers insertion orderc             O   sn   t |dkrtdt | y
| j W n6 tk
r\   g  | _}||dg|dd< i | _Y nX | j|| 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)rO   r   _OrderedDict__rootr   _OrderedDict__map_OrderedDict__update)r[   r   kwdsrootr   r   r   r]     s    

zOrderedDict.__init__c             C   sF   || kr6| j }|d }|||g |d<  |d< | j|< || || dS )z!od.__setitem__(i, y) <==> od[i]=yr   r   N)r  r	  )r[   rT   rU   Zdict_setitemr  lastr   r   r   r     s
     zOrderedDict.__setitem__c             C   s0   || | | j j|\}}}||d< ||d< dS )z od.__delitem__(y) <==> del od[y]r   r   N)r	  r   )r[   rT   Zdict_delitem	link_prev	link_nextr   r   r   r     s    
zOrderedDict.__delitem__c             c   s2   | j }|d }x||k	r,|d V  |d }qW dS )zod.__iter__() <==> iter(od)r   r   N)r  )r[   r  currr   r   r   r     s
    

zOrderedDict.__iter__c             c   s2   | j }|d }x||k	r,|d V  |d }qW dS )z#od.__reversed__() <==> reversed(od)r   r   N)r  )r[   r  r  r   r   r   __reversed__  s
    

zOrderedDict.__reversed__c             C   sh   yDx| j j D ]}|dd= qW | j}||dg|dd< | j j  W n tk
rX   Y nX tj|  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}|r8|d }|d }||d< ||d< n |d }|d }||d< ||d< |d }| j|= tj| |}||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  rT   rU   r   r   r   r     s     
zOrderedDict.popitemc             C   s   t | S )zod.keys() -> list of keys in od)r   )r[   r   r   r   keys  s    zOrderedDict.keysc                s    fdd D S )z#od.values() -> list of values in odc                s   g | ]} | qS r   r   )rm   rT   )r[   r   r   rq     s    z&OrderedDict.values.<locals>.<listcomp>r   )r[   r   )r[   r   values  s    zOrderedDict.valuesc                s    fdd D S )z.od.items() -> list of (key, value) pairs in odc                s   g | ]}| | fqS r   r   )rm   rT   )r[   r   r   rq     s    z%OrderedDict.items.<locals>.<listcomp>r   )r[   r   )r[   r   items  s    zOrderedDict.itemsc             C   s   t | S )z0od.iterkeys() -> an iterator over the keys in od)r   )r[   r   r   r   iterkeys  s    zOrderedDict.iterkeysc             c   s   x| D ]}| | V  qW dS )z2od.itervalues -> an iterator over the values in odNr   )r[   kr   r   r   r    s    
zOrderedDict.itervaluesc             c   s    x| D ]}|| | fV  qW dS )z=od.iteritems -> an iterator over the (key, value) items in odNr   )r[   r  r   r   r   	iteritems  s    
zOrderedDict.iteritemsc              O   s   t | dkr tdt | f n| s,td| d }f }t | dkrL| d }t|trrx^|D ]}|| ||< q\W nDt|drx8|j D ]}|| ||< qW nx|D ]\}}|||< qW x|j D ]\}}|||< qW d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  N)rO   r   r   r   hasattrr  r  )r   r  r[   otherrT   rU   r   r   r   rZ   	  s&    	


zOrderedDict.updatec             C   s0   || kr| | }| |= |S || j k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[   rT   r   r   r   r   r   r   ,  s    
zOrderedDict.popNc             C   s   || kr| | S || |< |S )zDod.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in odr   )r[   rT   r   r   r   r   
setdefault9  s    zOrderedDict.setdefaultc             C   s^   |si }t | t f}||kr"dS d||< z&| s>d| jjf S d| jj| j f S ||= X dS )zod.__repr__() <==> repr(od)z...r   z%s()z%s(%r)N)r   
_get_identr   r,   r  )r[   Z_repr_runningZcall_keyr   r   r   r   @  s     zOrderedDict.__repr__c                s\    fdd D }t  j }xt t D ]}|j|d q*W |rP j|f|fS  j|ffS )z%Return state information for picklingc                s   g | ]}| | gqS r   r   )rm   r  )r[   r   r   rq   P  s    z*OrderedDict.__reduce__.<locals>.<listcomp>N)varsr   r  r   r   )r[   r  	inst_dictr  r   )r[   r   
__reduce__N  s    zOrderedDict.__reduce__c             C   s
   | j | S )z!od.copy() -> a shallow copy of od)r   )r[   r   r   r   r   X  s    zOrderedDict.copyc             C   s    |  }x|D ]}|||< qW |S )zOD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
            and values equal to v (which defaults to None).

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

            )r   r  rO   r  r   __eq__)r[   r  r   r   r   r$  g  s    
 zOrderedDict.__eq__c             C   s
   | |k S )Nr   )r[   r  r   r   r   __ne__p  s    zOrderedDict.__ne__c             C   s   t | S )z@od.viewkeys() -> a set-like object providing a view on od's keys)r  )r[   r   r   r   viewkeysu  s    zOrderedDict.viewkeysc             C   s   t | S )z<od.viewvalues() -> an object providing a view on od's values)r  )r[   r   r   r   
viewvaluesy  s    zOrderedDict.viewvaluesc             C   s   t | S )zBod.viewitems() -> a set-like object providing a view on od's items)r  )r[   r   r   r   	viewitems}  s    zOrderedDict.viewitems)T)N)N)N)"r,   r-   r.   r^   r]   r   r   r   r   r  r   r   r  r  r  r  r  r  rZ   r
  objectr  r   r  r   r"  r   r   r   r$  r%  r&  r'  r(  r   r   r   r   r    s:   
	




	r  )BaseConfiguratorvalid_identz^[a-z_][a-z0-9_]*$c             C   s   t j| }|std|  dS )Nz!Not a valid Python identifier: %rT)
IDENTIFIERr=   rM   )r   r   r   r   r   r+    s    
r+  c               @   s"   e Zd ZdZdd ZdddZdS )ConvertingDictz A converting dictionary wrapper.c             C   sJ   t j| |}| jj|}||k	rF|| |< t|tttfkrF| |_||_	|S )N)
r   r   configuratorconvertr   r-  ConvertingListConvertingTupleparentrT   )r[   rT   rU   r   r   r   r   r     s    
zConvertingDict.__getitem__Nc             C   sL   t j| ||}| jj|}||k	rH|| |< t|tttfkrH| |_||_	|S )N)
r   rN   r.  r/  r   r-  r0  r1  r2  rT   )r[   rT   r   rU   r   r   r   r   rN     s    
zConvertingDict.get)N)r,   r-   r.   r^   r   rN   r   r   r   r   r-    s   r-  c             C   sD   t j| ||}| jj|}||k	r@t|tttfkr@| |_||_	|S )N)
r   r   r.  r/  r   r-  r0  r1  r2  rT   )r[   rT   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 )
r0  zA converting list wrapper.c             C   sJ   t j| |}| jj|}||k	rF|| |< t|tttfkrF| |_||_	|S )N)
r   r   r.  r/  r   r-  r0  r1  r2  rT   )r[   rT   rU   r   r   r   r   r     s    
zConvertingList.__getitem__r   c             C   s<   t j| |}| jj|}||k	r8t|tttfkr8| |_|S )N)	r   r   r.  r/  r   r-  r0  r1  r2  )r[   idxrU   r   r   r   r   r     s    
zConvertingList.popN)r4  )r,   r-   r.   r^   r   r   r   r   r   r   r0    s   r0  c               @   s   e Zd ZdZdd ZdS )r1  zA converting tuple wrapper.c             C   sB   t j| |}| jj|}||k	r>t|tttfkr>| |_||_	|S )N)
tupler   r.  r/  r   r-  r0  r1  r2  rT   )r[   rT   rU   r   r   r   r   r     s    
zConvertingTuple.__getitem__N)r,   r-   r.   r^   r   r   r   r   r   r1    s   r1  c               @   s   e Zd ZdZejdZejdZejdZejdZ	ej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 )r*  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)rn   cfgc             C   s   t || _| | j_d S )N)r-  configr.  )r[   r9  r   r   r   r]     s    
zBaseConfigurator.__init__c       	      C   s   |j d}|jd}y`| j|}xP|D ]H}|d| 7 }yt||}W q& tk
rl   | j| t||}Y q&X q&W |S  tk
r   tj dd \}}td||f }|| |_	|_
|Y nX dS )zl
            Resolve strings to objects using standard import and attribute
            syntax.
            r/   r   r   NzCannot resolve %r: %s)r1   r   importerr   r   ImportErrorrv   r   rM   	__cause____traceback__)	r[   r   r   usedfoundrF   etbvr   r   r   resolve  s"    




zBaseConfigurator.resolvec             C   s
   | j |S )z*Default converter for the ext:// protocol.)rC  )r[   rU   r   r   r   r6    s    zBaseConfigurator.ext_convertc             C   s  |}| j j|}|dkr&td| n||j d }| j|j d  }x|r| jj|}|rp||j d  }nd| jj|}|r|j d }| jj|s|| }n2yt	|}|| }W n t
k
r   || }Y nX |r||j d }qJtd||f qJW |S )z*Default converter for the cfg:// protocol.NzUnable to convert %rr   zUnable to convert %r at %r)WORD_PATTERNr=   rM   endr9  groupsDOT_PATTERNINDEX_PATTERNDIGIT_PATTERNintr   )r[   rU   restr   r#  r3  nr   r   r   r7    s2    
zBaseConfigurator.cfg_convertc             C   s   t |t r&t |tr&t|}| |_nt |t rLt |trLt|}| |_n|t |t rrt |trrt|}| |_nVt |tr| j	j
|}|r|j }|d }| jj|d}|r|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   r-  r   r.  r0  r   r1  r5  string_typesCONVERT_PATTERNr=   	groupdictvalue_convertersrN   r   )r[   rU   r   r#  rM  	converterr  r   r   r   r/  4  s*    


zBaseConfigurator.convertc                sr    j d}t|s| j|} j dd}t fdd D }|f |}|rnx |j D ]\}}t||| qVW |S )z1Configure an object with a user-supplied factory.z()r/   Nc                s    g | ]}t |r| | fqS r   )r+  )rm   r  )r9  r   r   rq   W  s    z5BaseConfigurator.configure_custom.<locals>.<listcomp>)r   r   rC  r   r  setattr)r[   r9  r   propsr\   r   r   rU   r   )r9  r   configure_customP  s    


z!BaseConfigurator.configure_customc             C   s   t |trt|}|S )z0Utility function which converts lists to tuples.)r   r   r5  )r[   rU   r   r   r   as_tuple^  s    
zBaseConfigurator.as_tupleN)r,   r-   r.   r^   r7   r:   rO  rD  rG  rH  rI  rQ  staticmethod
__import__r:  r]   rC  r6  r7  r/  rU  rV  r   r   r   r   r*    s    




"r*  )r   )r   r   )r   )N)N)
__future__r   r`   r7   rv   sslr;  version_infor   
basestringrN  r   r   typesr   Z	file_type__builtin__builtinsConfigParserconfigparserZ	_backportr   r   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%   htmlentitydefsZ	raw_input	itertoolsr&   filterr'   r)   iostrr(   urllib.parseurllib.requesturllib.errorhttp.clientclientrequestxmlrpc.clientZhtml.parserhtml.entitiesentitiesinputr*   r+   rM   rH   rW   rX   r)  r_   F_OKX_OKzipfiler   r   r  r   ZBaseZipExtFilerw   r   r   r   	NameErrorcollections.abcr   r   r   r   getfilesystemencodingr   r   tokenizer   codecsr   r   r:   r   r   htmlr8   cgir   collectionsr   r   reprlibr   r   importlib.utilr   impr  threadr   r  dummy_thread_abcollr  r  r  r   logging.configr*  r+  Ir,  r-  r   r   r0  r5  r1  r   r   r   r   <module>   s(  
$,(0




2+A


		
[
b
 w

