U
    x^                     @   s  d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlmZ ddlmZ ddlmZ d	d
 ZG dd deZdd Zdd Zdd Zdd Zdd Zdd Zdd ZG dd deZdd Zddd Zd!d" Zdd$d%Zdd'd(Zdd)d*Z d+d, Z!d-d. Z"dd0d1Z#G d2d3 d3eZ$d4d5 Z%d6d7 Z&dd9d:Z'd;d< Z(dd=d>Z)G d?d@ d@eZ*dAdB Z+G dCdD dDeZ,G dEdF dFeZ-ddGdHZ.G dIdJ dJeZ/dKdL Z0dMdN Z1dOdP Z2ddQdRZ3dSdT Z4dUdV Z5ddWdXZ6dYdZ Z7d[d\ Z8G d]d^ d^e9Z:G d_d` d`eZ;G dadb dbeZ<G dcdd dde=Z>dee>_?G dfde deeZ@daAdgdh ZBdidj ZCddldmZDG dndo doejEZFdpdq ZGdrds ZHdtdu ZIeJdvZKeJdwZLeLeKfdxdyZMeNdZOdzd{ ZPG d|d} d}eNZQd~d ZRdd ZSdd ZTdd ZUdd ZVdd ZWdS )zRoutines to help with the creation, loading and introspection of
modules, classes, hierarchies, attributes, functions, and methods.

    update_wrapperN   )_collections)compat   )excc                 C   s*   t jr| d} t }||  | S )Nzutf-8)r   py3kencodehashlibmd5update	hexdigest)xm r   C/tmp/pip-install-dq5v43_d/SQLAlchemy/sqlalchemy/util/langhelpers.pymd5_hex   s
    

r   c                   @   s.   e Zd ZdZdZdddZdd Zdd	 Zd
S )safe_reraiseaK  Reraise an exception after invoking some
    handler code.

    Stores the existing exception info before
    invoking so that it is maintained across a potential
    coroutine context switch.

    e.g.::

        try:
            sess.commit()
        except:
            with safe_reraise():
                sess.rollback()

    )	warn_only	_exc_infoFc                 C   s
   || _ d S N)r   )selfr   r   r   r   __init__8   s    zsafe_reraise.__init__c                 C   s   t  | _d S r   )sysexc_infor   r   r   r   r   	__enter__;   s    zsafe_reraise.__enter__c                 C   sz   |d kr0| j \}}}d | _ | jsvt||| nFtjsb| j rb| j d rbtd| j d | j d f  d | _ t||| d S )Nr   zfAn exception has occurred during handling of a previous exception.  The previous exception is:
 %s %s
r   )r   r   r   reraiser	   warn)r   type_value	tracebackexc_type	exc_valueexc_tbr   r   r   __exit__>   s    zsafe_reraise.__exit__N)F)__name__
__module____qualname____doc__	__slots__r   r   r&   r   r   r   r   r   $   s
   
r   c                 C   s   d dd td| jD S )N c                 s   s   | ]}|  V  qd S r   )lower).0nr   r   r   	<genexpr>S   s    z(clsname_as_plain_name.<locals>.<genexpr>z([A-Z][a-z]+))joinrefindallr'   )clsr   r   r   clsname_as_plain_nameR   s    
r5   c                 C   s>   g }| j | j| jfD ] }t|dr*| }|| qt|S )zrdecode a slice object as sent to __getitem__.

    takes into account the 2.5 __index__() method, basically.

    	__index__)startstopstephasattrr6   appendtuple)Zslcretr   r   r   r   decode_sliceX   s    
r>   c              	   '   sj   t | } |D ]X t ft fddtd}|D ] }|| kr6| | |V   qq6td  qd S )Nc                    s    t |  S r   )str)ibaser   r   <lambda>k       z!_unique_symbols.<locals>.<lambda>i  z&exhausted namespace for symbol base %s)set	itertoolschainr   Zitertools_imaprangeadd	NameError)usedbasespoolsymr   rA   r   _unique_symbolsf   s    
rO   c                 c   s*   |r&|| d @ }| |V  ||N }q dS )z6Call the given function given each nonzero bit from n.r   Nr   )fnr/   br   r   r   map_bitsv   s    
rR   c                    s    fdd}t | S )z'A signature-matching decorator factory.c                    s   t | st | stdt| }t|d |dd  | jf }t|dd\}}t	||d}|
t|dd	 | j|d
< d| }t|| || i| j}t| d| j|_| |_t|| S )Nznot a decoratable functionr   r      targetrP   )rT   rP   FgroupednamezDdef %(name)s(%(args)s):
    return %(target)s(%(fn)s, %(apply_kw)s)
im_func)inspect
isfunctionismethod	Exceptionr   inspect_getfullargspecr<   r'   rO   dictr   format_argspec_plus_exec_code_in_envgetattr__defaults____wrapped__r   )rP   specnamesZ	targ_namefn_namemetadatacode	decoratedrT   r   r   decorate   s(    
 
 
 zdecorator.<locals>.decorater   )rT   rk   r   rj   r   	decorator   s    rl   c                 C   s   t | | || S r   )exec)rh   envrf   r   r   r   r`      s    
r`   c                 C   s   t | tr$| j}| }d| j|f }n|  }}d| }|dd }t|}|d d= t|dd}||d< d	| }|td
}	t	||	 |	| }
|j
|
_
d|ddd  |
_tjst|dr||j_
n||_
|
S )zProduce a wrapping function for the given cls or classmethod.

    Rationale here is so that the __init__ method of the
    class can serve as documentation for the function.

    zConstruct a new :class:`.%s` object. 

This constructor is mirrored as a public API function; see :func:`~%s` for a full usage and argument description.zJThis function is mirrored; see :func:`~%s` for a description of arguments..r   FrU   rW   z5def %(name)s(%(args)s):
    return cls(%(apply_kw)s)
)r4   symbolZ
sqlalchemyr   __func__)
isinstancetyper   r'   splitr   r]   r_   rq   rm   r*   rsplitr(   py2kr:   rr   )rT   locationrP   Z	callable_docZlocation_namerd   rg   rh   rn   ri   r   r   r   public_factory   s<    





rz   c                   @   s.   e Zd Zd
ddZdd Zdd Zdd	 ZdS )PluginLoaderNc                 C   s   || _ i | _|| _d S r   )groupimplsauto_fn)r   r|   r~   r   r   r   r      s    zPluginLoader.__init__c                 C   s   | j   d S r   )r}   clearr   r   r   r   r      s    zPluginLoader.clearc                 C   s   || j kr| j |  S | jr:| |}|r:|| j |< | S zdd l}W n tk
rZ   Y n,X || j|D ]}|j| j |< |   S td| j|f d S )Nr   zCan't load plugin: %s:%s)	r}   r~   pkg_resourcesImportErroriter_entry_pointsr|   loadr   ZNoSuchModuleError)r   rW   loaderr   implr   r   r   r      s"    


zPluginLoader.loadc                    s    fdd}|| j |< d S )Nc                     s6   t  }  ddd  D ]}t| |} qt| S )Nro   r   )r   import_ru   ra   )modtoken
modulepathobjnamer   r   r      s    
z#PluginLoader.register.<locals>.load)r}   )r   rW   r   r   r   r   r   r   register   s    zPluginLoader.register)N)r'   r(   r)   r   r   r   r   r   r   r   r   r{      s   
r{   c                 C   sn   z
t j}W n2 tk
r<   t| }|d t|d f Y S X | j}|j}t|j	d | t|j
|@ fS d S )Nr   r   )rY   CO_VARKEYWORDSAttributeErrorr   r]   bool__code__co_argcountlistco_varnamesco_flags)rP   Zco_varkeywordsrd   conargsr   r   r   _inspect_func_args   s    

r   c                 C   s   |dk}|rt  }| jdd}|o<t|tjo<t|jtj}|rdt|\}}|	| |sd|sddS |rl|r| j
D ]}t||dkrr qqr|d |S )ae  Return the full set of inherited kwargs for the given `cls`.

    Probes a class's __init__ method, collecting all named arguments.  If the
    __init__ defines a \**kwargs catch-all, then the constructor is presumed
    to pass along unrecognized keywords to its base classes, and the
    collection process is repeated recursively on each of the bases.

    Uses a subset of inspect.getfullargspec() to cut down on method overhead,
    as this is used within the Core typing system to create copies of type
    objects which is a performance-sensitive operation.

    No anonymous tuple arguments please !

    Nr   Fr   )rE   __dict__getrs   typesFunctionTyper   CodeTyper   r   	__bases__get_cls_kwargsdiscard)r4   Z_settoplevelZctrZhas_initre   Zhas_kwcr   r   r   r     s(    



r   c                 C   s   t | d S )zReturn the set of legal kwargs for the given `func`.

    Uses getargspec so is safe to call for methods, functions,
    etc.

    r   )r   r]   funcr   r   r   get_func_kwargs<  s    r   Fc              	   C   sD  t | rtd|  n&t | rn|rb|rbt| }t|jdd |j|j	|j
|j|j|jS t| S nt | r|r|s| jrt| j}t|jdd |j|j	|j
|j|j|jS t| jS ntt | rt| j|ddS t| d rt| jS t| dr4t | jr&t| j|dS td	|  ntd	|  dS )
zReturn the argument signature for any callable.

    All pure-Python callables are accepted, including
    functions, methods, classes, objects with __call__;
    builtins and other edge cases like functools.partial() objects
    raise a TypeError.

    zCan't inspect builtin: %sr   NT)no_self_is_initrr   __call__)r   zCan't inspect callable: %s)rY   	isbuiltin	TypeErrorrZ   r   r]   FullArgSpecargsvarargsvarkwdefaults
kwonlyargskwonlydefaultsannotationsr[   __self__rr   isclassget_callable_argspecr   r:   r   )rP   r   r   rd   r   r   r   r   G  sR    	






  r   Tc           
      C   s6  t | rt | }n| }t j| }|d r:|d d }n|d rPd|d  }nd}t |d |d |d d|d }d}|d r|t|d 7 }|d r|t|d 7 }|d |d  }|r|d| d }nd}t j||d |d |d	d
 d}	|r
t||||	dS t|dd ||dd |	dd dS dS )a  Returns a dictionary of formatted, introspected function arguments.

    A enhanced variant of inspect.formatargspec to support code generation.

    fn
       An inspectable callable or tuple of inspect getargspec() results.
    grouped
      Defaults to True; include (parens, around, argument) lists

    Returns:

    args
      Full inspect.formatargspec for fn
    self_arg
      The name of the first positional argument, varargs[0], or None
      if the function defines no positional arguments.
    apply_pos
      args, re-written in calling rather than receiving syntax.  Arguments are
      passed positionally.
    apply_kw
      Like apply_pos, except keyword-ish args are passed as keywords.

    Example::

      >>> format_argspec_plus(lambda self, a, b, c=3, **d: 123)
      {'args': '(self, a, b, c=3, **d)',
       'self_arg': 'self',
       'apply_kw': '(self, a, b, c=c, **d)',
       'apply_pos': '(self, a, b, c, **d)'}

    r   r   z%s[0]Nr      rS   r   c                 S   s   d|  S )N=r   )r   r   r   r   rC     rD   z%format_argspec_plus.<locals>.<lambda>)formatvalue)r   self_arg	apply_posapply_kwrp   )r   callabler]   inspect_formatargspeclenr^   )
rP   rV   rd   r   r   r   num_defaultsZ	name_argsZdefaulted_valsr   r   r   r   r_   }  sZ     

    


r_   c                 C   sX   | t jkr|rdpd}n0zt| |dW S  tk
rF   |r>dp@d}Y nX td|||dS )a  format_argspec_plus with considerations for typical __init__ methods

    Wraps format_argspec_plus with error handling strategies for typical
    __init__ cases::

      object.__init__ -> (self)
      other unreflectable (usually C) -> (self, *args, **kwargs)

    z(self)r   rU   z(self, *args, **kwargs)zself, *args, **kwargs)r   r   r   r   )objectr   r_   r   r^   )methodrV   r   r   r   r   format_argspec_init  s    

r   c                 C   sT   zt | W S  tk
rN   | tjkr8dgdddf Y S dgdddf Y S Y nX dS )zinspect.getargspec with considerations for typical __init__ methods

    Wraps inspect.getargspec with error handling for typical __init__ cases::

      object.__init__ -> (self)
      other unreflectable (usually C) -> (self, *args, **kwargs)

    r   Nr   kwargs)r   r]   r   r   r   )r   r   r   r   getargspec_init  s    	
r   c                 C   s    t | tjr| js| jS | S dS )zSAdjust the incoming callable such that a 'self' argument is not
    required.

    N)rs   r   
MethodTyper   rr   )Zfunc_or_clsr   r   r   unbound_method_to_callable  s    r   r   c              	      sL  |dkrg}n
t |}t  g }t  }d}t|D ]\}}zt|j}	W n tk
rh   Y q8Y q8X |	j	rzt
|	j	p|d}
|dkr|	jr|	j}|
r||	jd|
   q||	jdd  n$| fdd|	jd|
  D  |
r8|dd t|	j|
 d |	j	D  q8g }|fdd|D  |dk	rbt|rb|d	d t|D  | D ]f\}}||krqjz6t| }| k	r||kr|d
||f  W n tk
r   Y nX qj|r6|D ]X\}}z6t| }| k	r||kr|d
||f  W n tk
r0   Y nX qdjjd|f S )z}Produce a __repr__() based on direct association of the __init__()
    specification vs. same-named attributes present.

    Nr   r   c                    s   g | ]}| fqS r   r   r.   arg)missingr   r   
<listcomp>%  s     z generic_repr.<locals>.<listcomp>c                 S   s   g | ]\}}||fqS r   r   )r.   r   defaultr   r   r   r   *  s   c                 3   s   | ]}t t |d V  qd S r   )reprra   r   objr   r   r0   3  s     zgeneric_repr.<locals>.<genexpr>c                 S   s   g | ]}t |qS r   r   )r.   valr   r   r   r   6  s     z%s=%rz%s(%s), )r   to_listr   OrderedDict	enumerater   r]   r   r   r   r   r   extendr   r   zipr:   ra   itemsr;   r\   	__class__r'   r1   )r   Zadditional_kwZ
to_inspectZ
omit_kwargZpos_argsZkw_argsZvargsr@   Zinsprd   Zdefault_lenoutputr   Zdefvalr   r   )r   r   r   generic_repr  sj    

 


r   c                   @   s6   e Zd ZdZdZdd Zdd Zddd	Zd
d ZdS )portable_instancemethodz_Turn an instancemethod into a (parent, name) pair
    to produce a serializable callable.

    )rT   rW   r   __weakref__c                 C   s   | j | j| jdS )NrT   rW   r   r   r   r   r   r   __getstate__V  s    z$portable_instancemethod.__getstate__c                 C   s&   |d | _ |d | _|dd| _d S )NrT   rW   r   r   )rT   rW   r   r   )r   stater   r   r   __setstate__]  s    

z$portable_instancemethod.__setstate__r   c                 C   s   |j | _|j| _|| _d S r   )r   rT   r'   rW   r   )r   methr   r   r   r   r   b  s    z portable_instancemethod.__init__c                 O   s    | | j t| j| j||S r   )r   r   ra   rT   rW   )r   r   kwr   r   r   r   g  s    z portable_instancemethod.__call__N)r   )	r'   r(   r)   r*   r+   r   r   r   r   r   r   r   r   r   N  s   
r   c                    s   t jrt| tjrt S | h t| j}|r| }t jr^t|tjrHq( fdd|jD }n fdd|jD }|D ]}|	|  
| qvt jr|jdks(t|dsq(n|jdks(t|dsq( fdd| D D ]}|	|  
| qq(t S )	a  Return an unordered sequence of all classes related to cls.

    Traverses diamond hierarchies.

    Fibs slightly: subclasses of builtin types are not returned.  Thus
    class_hierarchy(class A(object)) returns (A, object), not A plus every
    class systemwide that derives from object.

    Old-style classes are discarded and hierarchies rooted on them
    will not be descended.

    c                 3   s&   | ]}| krt |tjs|V  qd S r   )rs   r   	ClassTyper.   _Zhierr   r   r0     s    z"class_hierarchy.<locals>.<genexpr>c                 3   s   | ]}| kr|V  qd S r   r   r   r   r   r   r0     s      builtins__subclasses____builtin__c                    s   g | ]}| kr|qS r   r   r   r   r   r   r     s      z#class_hierarchy.<locals>.<listcomp>)r   rw   rs   r   r   r   __mro__popr   r;   rI   r	   r(   r:   r   )r4   processr   rL   rQ   sr   r   r   class_hierarchyl  s:    


 
r   c                 c   s@   t | }|D ].}| jD ]"}||jkr||j| fV   qqqdS )ziterate all the keys and attributes associated
       with a class, without using getattr().

       Does not use getattr() so that class-sensitive
       descriptors (i.e. property.__get__()) are not called.

    N)dirr   r   )r4   keyskeyr   r   r   r   iterate_attributes  s    

r   
self.proxyc              	      s0  |r
|}n$dkrd fddt |D }|D ]}z(t||}t|dsPW q2t|d|}W n tk
rv   Y q2Y nX z2t|}	t|	d }
t|	d dd }W n tk
r   d	}
d
}Y nX dt  }|dk	r||ipi }t	|| z|j
|| _
W n tk
r   Y nX t |||  q2dS )z9Automates delegation of __specials__ for a proxying type.N)r+   __del____getattribute____metaclass__r   r   c                    s6   g | ].}| d r|d rt |s|kr|qS )__)
startswithendswithr:   r.   r   into_clsskipr   r   r     s   


z0monkeypatch_proxied_specials.<locals>.<listcomp>r   rX   r   r   z(self, *args, **kw)z(*args, **kw)z?def %(method)s%(fn_args)s: return %(name)s.%(method)s%(d_args)s)r   ra   r:   r   r   r]   r   r   localsexec_rb   setattr)r   Zfrom_clsr   onlyrW   Zfrom_instanceZdundersr   rP   rd   Zfn_argsZd_argspyrn   r   r   r   monkeypatch_proxied_specials  sB    





r  c                 C   s   t | d| t |d|kS )z;Return True if the two methods are the same implementation.rr   )ra   )Zmeth1Zmeth2r   r   r   methods_equivalent  s
      r  c                 C   st  |s|st dt|tr(t| |r(| S t|p>dd t|D }tt| }tj}t|trd|}n|svt }tj}nt|}||||r| S t| t	s|tjkrdpd}t d| |d
|f G dd	 d	t}|rd
|j |_t }	t| D ]T\}
}|
|krt d|
 t|s.t d|
|f t||
t| |	|
 q||	|rZ|S t dd
||	  dS )a  Ensure basic interface compliance for an instance or dict of callables.

    Checks that ``obj`` implements public methods of ``cls`` or has members
    listed in ``methods``. If ``required`` is not supplied, implementing at
    least one interface method is sufficient. Methods present on ``obj`` that
    are not in the interface are ignored.

    If ``obj`` is a dict and ``dict`` does not meet the interface
    requirements, the keys of the dictionary are inspected. Keys present in
    ``obj`` that are not in the interface will raise TypeErrors.

    Raises TypeError if ``obj`` does not meet the interface criteria.

    In all passing cases, an object with callable members is returned.  In the
    simple case, ``obj`` is returned as-is; if dict processing kicks in then
    an anonymous class is returned.

    obj
      A type, instance, or dictionary of callables.
    cls
      Optional, a type.  All public methods of cls are considered the
      interface.  An ``obj`` instance of cls will always pass, ignoring
      ``required``..
    methods
      Optional, a sequence of method names to consider as the interface.
    required
      Optional, a sequence of mandatory implementations. If omitted, an
      ``obj`` that provides at least one interface method is considered
      sufficient.  As a convenience, required may be a type, in which case
      all public methods of the type are required.

    z2a class or collection of method names are requiredc                 S   s   g | ]}| d s|qS )r   )r   r   r   r   r   r     s     
 z as_interface.<locals>.<listcomp>zany ofzall ofz%r does not implement %s: %sr   c                   @   s   e Zd ZdZdS )z(as_interface.<locals>.AnonymousInterfacezA callable-holding shell.N)r'   r(   r)   r*   r   r   r   r   AnonymousInterface4  s   r  Z	Anonymousz%r: unknown in this interfacez%r=%r is not callablez,dictionary does not contain required keys %sN)r   rs   rt   rE   r   operatorgegtintersectionr^   r1   r   r'   dictlike_iteritemsr   r   r   staticmethodrI   )r   r4   methodsrequiredZ	interfaceZimplementedZcompliesZ	qualifierr  foundr   r   r   r   r   as_interface  sP    !


r  c                   @   s6   e Zd ZdZdddZdd Zdd Zed	d
 ZdS )memoized_propertyz2A read-only @property that is only evaluated once.Nc                 C   s   || _ |p|j| _|j| _d S r   )fgetr*   r'   )r   r  ry   r   r   r   r   O  s    zmemoized_property.__init__c                 C   s&   |d kr| S |  | |j| j< }|S r   )r  r   r'   )r   r   r4   resultr   r   r   __get__T  s    zmemoized_property.__get__c                 C   s   t || j d S r   )r  resetr'   )r   r   r   r   r   _resetZ  s    zmemoized_property._resetc                 C   s   |j |d  d S r   )r   r   )r4   r   rW   r   r   r   r  ]  s    zmemoized_property.reset)N)	r'   r(   r)   r*   r   r  r  classmethodr  r   r   r   r   r  L  s   
r  c                    s    fdd}t | S )zDecorate a method memoize its return value.

    Best applied to no-arg methods: memoization is not sensitive to
    argument values, and will always return the same value even when
    called with different arguments.

    c                    s<   | f||  fdd}j |_ j|_|| jj <  S )Nc                     s    S r   r   ar   r  r   r   memon  s    z6memoized_instancemethod.<locals>.oneshot.<locals>.memo)r'   r*   r   )r   r   r   r  rP   r  r   oneshotk  s    z(memoized_instancemethod.<locals>.oneshotr   )rP   r  r   r  r   memoized_instancemethodb  s    	r  c                   @   s2   e Zd ZdZdddZdd Zdd Zd	d
 ZdS )!group_expirable_memoized_propertyz?A family of @memoized_properties that can be expired in tandem.r   c                 C   s   g | _ |r| j | d S r   )
attributesr   )r   r  r   r   r   r   |  s    z*group_expirable_memoized_property.__init__c                 C   s"   |j }| jD ]}||d qdS )z.Expire all memoized properties for *instance*.N)r   r  r   )r   instancestash	attributer   r   r   expire_instance  s    
z1group_expirable_memoized_property.expire_instancec                 C   s   | j |j t|S r   )r  r;   r'   r  r   rP   r   r   r   r     s    z*group_expirable_memoized_property.__call__c                 C   s   | j |j t|S r   )r  r;   r'   r  r#  r   r   r   r     s    z(group_expirable_memoized_property.methodN)r   )r'   r(   r)   r*   r   r"  r   r   r   r   r   r   r  y  s
   
r  c                   @   s$   e Zd ZdZdZdd Zdd ZdS )MemoizedSlotszApply memoized items to an object using a __getattr__ scheme.

    This allows the functionality of memoized_property and
    memoized_instancemethod to be available to a class using __slots__.

    r   c                 C   s   t |d S r   )r   )r   r   r   r   r   _fallback_getattr  s    zMemoizedSlots._fallback_getattrc                    s    drtnptd rBtd  }t| |S td rztd   fdd} j|_|S S d S )NZ	_memoizedz_memoized_attr_%sz_memoized_method_%sc                     s6   | |  fdd}j |_ j|_t|  S )Nc                     s    S r   r   r  r  r   r   r    s    z8MemoizedSlots.__getattr__.<locals>.oneshot.<locals>.memo)r'   r*   r   )r   r   r  rP   r   r   r  r   r    s    
z*MemoizedSlots.__getattr__.<locals>.oneshot)r   r   r:   ra   r   r*   r%  )r   r   r!   r  r   r&  r   __getattr__  s    

zMemoizedSlots.__getattr__N)r'   r(   r)   r*   r+   r%  r'  r   r   r   r   r$    s   r$  c                    s    fdd}|S )Nc                    sn    d}td|dd t t |d g}t||d }t|| j|   rjt	|drj|j
| j | S )Nro   r   rp   __all__)ru   r   r   r1   globalsr   ra   r   r'   r:   r(  r;   )r   tokensr   
add_to_all
modulenamer   r   rk     s    
   z dependency_for.<locals>.decorater   )r-  r,  rk   r   r+  r   dependency_for  s    r.  c                   @   sF   e Zd ZdZdd Zdd Zedd Ze Z	i Z
G dd	 d	eZd
S )dependenciesa  Apply imported dependencies as arguments to a function.

    E.g.::

        @util.dependencies(
            "sqlalchemy.sql.widget",
            "sqlalchemy.engine.default"
        );
        def some_func(self, widget, default, arg1, arg2, **kw):
            # ...

    Rationale is so that the impact of a dependency cycle can be
    associated directly with the few functions that cause the cycle,
    and not pollute the module-level namespace.

    c              
   G   sD   g | _ |D ]4}|d}| j td|dd |d  q
d S )Nro   r   rp   )import_depsru   r;   r/  _importlaterr1   )r   depsdepr*  r   r   r   r     s    
zdependencies.__init__c                 C   s   | j }t|}t|d }|d dk}tt|D ] }d| |d ||rNdnd < q4t|dd}|D ]}||rtdnd= qf||d d d < t|dd}	d|	d |d	 d
 }
t|
t }t	|d|j
|_
t||S )Nr   )r   r4   zimport_deps[%r]r   FrU   z!lambda %(args)s: fn(%(apply_kw)s)r   r   )r   r   rX   )r0  r   r]   r   rH   r   r_   evalr   ra   rb   r   )r   rP   r0  rd   Z	spec_zeroZhasselfr@   Z
inner_specZimpnameZ
outer_specrh   ri   r   r   r   r     s$    
zdependencies.__call__c                 C   s(   t tjD ]}|j|r
|  q
d S r   )r   r/  _unresolved
_full_pathr   _resolve)r4   pathr   r   r   r   resolve_all  s    zdependencies.resolve_allc                   @   sN   e Zd Ze Zi Zdd Zdd Zedd Z	e
dd Zd	d
 Zdd ZdS )zdependencies._importlaterc                 C   s<   |d | }|t jkr t j| S t|  t j|< }|S d S Nro   )r/  _by_keyr   __new__)r4   r8  addtlr   impr   r   r   r<  
  s
    

z!dependencies._importlater.__new__c                 C   s   || _ || _tj|  d S r   )_il_path	_il_addtlr/  r5  rI   )r   r8  r=  r   r   r   r     s    z"dependencies._importlater.__init__c                 C   s   | j d | j S r:  )r?  r@  r   r   r   r   r6    s    z$dependencies._importlater._full_pathc                 C   s,   | t jkrtd| j| jf t| j| jS )Nz<importlater.resolve_all() hasn't been called (this is %s %s))r/  r5  r   r?  r@  ra   _initial_importr   r   r   r   module  s    

z dependencies._importlater.modulec                 C   s,   t j|  t| jt t | jg| _	d S r   )
r/  r5  r   r   r   r?  r)  r   r@  rA  r   r   r   r   r7  &  s       z"dependencies._importlater._resolvec                 C   s\   |dkrt d| j zt| j|}W n& tk
rL   td| j|f Y nX || j|< |S )NrB  zCould not resolve module %szModule %s has no attribute '%s')r   r6  ra   rB  r   r   )r   r   attrr   r   r   r'  ,  s    

z%dependencies._importlater.__getattr__N)r'   r(   r)   rE   r5  r;  r<  r   propertyr6  r  rB  r7  r'  r   r   r   r   r1    s   


r1  N)r'   r(   r)   r*   r   r   r  r9  rE   r5  r;  r   r1  r   r   r   r   r/    s   
r/  c                 C   sD   t | tjr<|   } | dkr$dS | dkr0dS td|  t| S )N)trueyesonyt1T)falsenooffr/   f0FzString is not true/false: %r)rs   r   string_typesstripr-   
ValueErrorr   r   r   r   r   asbool<  s    rS  c                     s    fdd}|S )zqReturn a callable that will evaluate a string as
    boolean, or one of a set of "alternate" string values.

    c                    s   |  kr| S t | S d S r   )rS  r   textr   r   bool_or_valueN  s    z"bool_or_str.<locals>.bool_or_valuer   )rU  rV  r   rT  r   bool_or_strH  s    rW  c                 C   s   | dkr| S t | S )zCoerce to integer.N)int)r!   r   r   r   asintW  s    rY  c                 C   sj   |dkr| }|| krft |tr,t | | |sf| | dk	rf|tkrV|rVt| | ||< n|| | ||< dS )zIf 'key' is present in dict 'kw', coerce its value to type 'type\_' if
    necessary.  If 'flexi_bool' is True, the string '0' is considered false
    when coercing to boolean.
    N)rs   rt   r   rS  )r   r   r    Z
flexi_booldestr   r   r   coerce_kw_type_  s    
r[  c                    s0   t |}| fdd||D  |||S )zInstantiate cls using the __dict__ of obj as constructor arguments.

    Uses inspect to match the named arguments of ``cls``.

    c                 3   s&   | ]}| j kr| j | fV  qd S r   )r   )r.   kr   r   r   r0   {  s    
 z#constructor_copy.<locals>.<genexpr>)r   r   
difference)r   r4   r   r   re   r   r   r   constructor_copys  s
    r^  c                     s&   t j td  fdd} | S )z%Return a threadsafe counter function.r   c                      s$      zt W S   X d S r   )acquirereleasenextr   counterlockr   r   _next  s    zcounter.<locals>._next)r   	threadingLockrF   count)re  r   rb  r   rc    s    

rc  c                 C   s   t | dr*| jdk	r$t| jtr$tS | jS t| tr8tp:t}|| trJtS || trXtS || trftS t | drttS t | drtS t | drtS |S dS )zGiven an instance or class, guess if it is or is acting as one of
    the basic collection types: list, set and dict.  If the __emulates__
    property is present, return that preferentially.
    __emulates__Nr;   rI   rE   )r:   ri  
issubclassrE   rs   rt   r   r^   )Zspecimenr   Zisar   r   r   duck_type_collection  s*    
 





rk  c                 C   s^   t | |r| S t |trBtd|ddd |D t| f ntd||t| f d S )Nz8Argument '%s' is expected to be one of type %s, got '%s'z or c                 s   s   | ]}d | V  qdS )z'%s'Nr   )r.   r  r   r   r   r0     s     z"assert_arg_type.<locals>.<genexpr>z6Argument '%s' is expected to be of type '%s', got '%s')rs   r<   r   ArgumentErrorr1   rt   )r   ZargtyperW   r   r   r   assert_arg_type  s    

rm  c                    s   t jrt drFt  S n(t dr0  S t drFt  S t dt dddkrntd  t dr fdd	}| S t d
rtfdd 	 D S td  dS )z?Return a (key, value) iterator for almost any dict-like object.r   	iteritems__getitem__r   NzObject '%r' is not dict-likeiterkeysc                  3   s       D ]} | | fV  qd S r   )rp  )r   dictlikegetterr   r   iterator  s    z$dictlike_iteritems.<locals>.iteratorr   c                 3   s   | ]}| |fV  qd S r   r   )r.   r   )rs  r   r   r0     s     z%dictlike_iteritems.<locals>.<genexpr>)
r   r	   r:   r   r   rn  iterra   r   r   )rr  rt  r   rq  r   r	    s     




r	  c                       s(   e Zd ZdZ fddZdd Z  ZS )classpropertyaA  A decorator that behaves like @property except that operates
    on classes rather than instances.

    The decorator is currently special when using the declarative
    module, but note that the
    :class:`~.sqlalchemy.ext.declarative.declared_attr`
    decorator should be used for this purpose with declarative.

    c                    s$   t t| j|f|| |j| _d S r   )superrv  r   r*   )r   r  r   r   r   r   r   r     s    zclassproperty.__init__c                 C   s
   |  |S r   )r  )descr   r4   r   r   r   r    s    zclassproperty.__get__)r'   r(   r)   r*   r   r  __classcell__r   r   rx  r   rv    s   
rv  c                   @   s   e Zd Zdd Zdd ZdS )hybridpropertyc                 C   s
   || _ d S r   r   r   r   r   r   r   r     s    zhybridproperty.__init__c                 C   s.   |d kr |  |}| j j|_|S |  |S d S r   )r   r*   )r   r  ownerZclsvalr   r   r   r    s
    

zhybridproperty.__get__N)r'   r(   r)   r   r  r   r   r   r   r{    s   r{  c                   @   s    e Zd ZdZdd Zdd ZdS )hybridmethodz/Decorate a function as cls- or instance- level.c                 C   s
   || _ d S r   r   r|  r   r   r   r     s    zhybridmethod.__init__c                 C   s*   |d kr| j ||jS | j ||S d S r   )r   r  r   )r   r  r}  r   r   r   r    s    zhybridmethod.__get__N)r'   r(   r)   r*   r   r  r   r   r   r   r~     s   r~  c                   @   s.   e Zd Zd
ddZdd Zdd Zdd	 ZdS )_symbolNc                 C   s@   t |tjst|dkr t|}tt|}||_|r<||_	|S )zConstruct a new named symbol.N)
rs   r   rP  AssertionErrorhashrX  r<  r  rW   r*   )r   rW   ry   	canonicalvr   r   r   r<    s    z_symbol.__new__c                 C   s   t | jdt| ffS )Nr   )rq   rW   rX  r   r   r   r   
__reduce__  s    z_symbol.__reduce__c                 C   s   t | S r   r   r   r   r   r   __str__  s    z_symbol.__str__c                 C   s
   d| j  S )Nz
symbol(%r))rW   r   r   r   r   __repr__  s    z_symbol.__repr__)NN)r'   r(   r)   r<  r  r  r  r   r   r   r   r    s   
r  rq   c                   @   s6   e Zd ZdZi Zej ZdddZ	e
d	ddZdS )
rq   a  A constant symbol.

    >>> symbol('foo') is symbol('foo')
    True
    >>> symbol('foo')
    <symbol 'foo>

    A slight refinement of the MAGICCOOKIE=object() pattern.  The primary
    advantage of symbol() is its repr().  They are also singletons.

    Repeated calls of symbol('name') will all return the same instance.

    The optional ``doc`` argument assigns to ``__doc__``.  This
    is strictly so that Sphinx autoattr picks up the docstring we want
    (it doesn't appear to pick up the in-module docstring if the datamember
    is in a different module - autoattribute also blows up completely).
    If Sphinx fixes/improves this then we would no longer need
    ``doc`` here.

    Nc                 C   sN   | j   z2| j|}|d kr6t||| | j|< }|W S tj   X d S r   )_lockr_  rq   r`  symbolsr   r  )r4   rW   ry   r  rN   r   r   r   r<  ?  s    
zsymbol.__new__Fc                 C   sj   |  D ]>\}}||kr |  S |r6||jkr6|  S ||kr|  S q|dkrTdS td||f dS )a  Given a user parameter, parse the parameter into a chosen symbol.

        The user argument can be a string name that matches the name of a
        symbol, or the symbol object itself, or any number of alternate choices
        such as True/False/ None etc.

        :param arg: the user argument.
        :param choices: dictionary of symbol object to list of possible
         entries.
        :param name: name of the argument.   Used in an :class:`.ArgumentError`
         that is raised if the parameter doesn't match any available argument.
        :param resolve_symbol_names: include the name of each symbol as a valid
         entry.

        NzInvalid value for '%s': %r)r   rW   r   rl  )r4   r   choicesrW   Zresolve_symbol_namesrN   choicer   r   r   parse_user_argumentI  s    
zsymbol.parse_user_argument)NN)F)r'   r(   r)   r*   r  r   rf  rg  r  r<  r  r  r   r   r   r   rq   &  s   


 c                 C   s   t | _ t d7 a dS )zAssign a '_creation_order' sequence to the given instance.

    This allows multiple instances to be sorted in order of creation
    (typically within a single thread; the counter is not particularly
    threadsafe).

    r   N)_creation_order)r  r   r   r   set_creation_orderp  s    	r  c                 O   s>   z| ||W S  t k
r8   tdt dd   Y nX dS )zXexecutes the given function, catches all exceptions and converts to
    a warning.

    z%s('%s') ignoredr   r   N)r\   r   r   r   )r   r   r   r   r   r   warn_exception}  s    r     c                 C   sF   z(t | |kr d| d|  W S | W S W n tk
r@   |  Y S X d S )Nz%s...r   )r   r   )r!   Zlen_r   r   r   ellipses_string  s    
r  c                       s0   e Zd ZdZ fddZdd Zdd Z  ZS )_hash_limit_stringa/  A string subclass that can only be hashed on a maximum amount
    of unique values.

    This is used for warnings so that we can send out parameterized warnings
    without the __warningregistry__ of the module,  or the non-overridable
    "once" registry within warnings.py, overloading memory,


    c                    s@   || d|  }t t| | |}td|t|| f |_|S )Nz6 (this warning may be suppressed after %d occurrences)z%s_%d)rw  r  r<  r  _hash)r4   r!   numr   Zinterpolatedr   rx  r   r   r<    s    z_hash_limit_string.__new__c                 C   s   | j S r   )r  r   r   r   r   __hash__  s    z_hash_limit_string.__hash__c                 C   s   t | t |kS r   )r  )r   otherr   r   r   __eq__  s    z_hash_limit_string.__eq__)r'   r(   r)   r*   r<  r  r  rz  r   r   rx  r   r    s   
r  c                 C   s   t j| tjdd dS )zdIssue a warning.

    If msg is a string, :class:`.exc.SAWarning` is used as
    the category.

    r   
stacklevelN)warningsr   r   	SAWarning)msgr   r   r   r     s    r   c                 C   s&   |rt | d|} tj| tjdd dS )z\Issue a warning with a parameterized string, limiting the number
    of registrations.

    
   r   r  N)r  r  r   r   r  )r  r   r   r   r   warn_limited  s    r  c                    s    g fdd}|S )zNDecorate the given function to be a no-op after it is called exactly
    once.c                     s@    }r<  }z|| |W S    r4d|  Y nX d S )Nr   )r   insert)r   r   Z	strong_fnZonce_fnrP   onceretry_on_exceptionr   r   go  s    zonly_once.<locals>.gor   )rP   r  r  r   r  r   	only_once  s    r  z%sqlalchemy/([a-z_]+/){0,2}[a-z_]+\.pyzunit(?:2|test2?/)c                 C   s`   d}t | d }||kr0|| | r0|d7 }q||krP|| | rP|d8 }q0| ||d  S )at  Chop extraneous lines off beginning and end of a traceback.

    :param tb:
      a list of traceback lines as returned by ``traceback.format_stack()``

    :param exclude_prefix:
      a regular expression object matching lines to skip at beginning of
      ``tb``

    :param exclude_suffix:
      a regular expression object matching lines to skip at end of ``tb``
    r   r   )r   search)tbZexclude_prefixZexclude_suffixr7   endr   r   r   chop_traceback  s    

r  c                 C   s$   d|  }t   }t|| |d S )Nz&def set(obj, value):    obj.%s = valuerE   )r   copyrm   )attrnamerh   rn   r   r   r   
attrsetter  s    

r  c                       s(   e Zd ZdZ fddZdd Z  ZS )EnsureKWArgTypezYApply translation of functions to accept \**kw arguments if they
    don't already.

    c           
         sr   | j }|rZ|D ]J}t||}|r|| }t|}|js| | ||< }	t| ||	 qtt	| 
||| d S r   )Zensure_kwargr2   matchr   r]   r   
_wrap_w_kwr   rw  r  r   )
r4   ZclsnamerL   ZclsdictZfn_regr   r   rP   rd   wrappedrx  r   r   r      s    
zEnsureKWArgType.__init__c                    s    fdd}t | S )Nc                     s    |  S r   r   )r   r   r  r   r   wrap  s    z(EnsureKWArgType._wrap_w_kw.<locals>.wrapr   )r   rP   r  r   r  r   r    s    zEnsureKWArgType._wrap_w_kw)r'   r(   r)   r*   r   r  rz  r   r   rx  r   r    s   r  c                 C   sj   t |drt| |S | }|jj|_t |dr4|j|_t |jdrT|jjrT|jj|_n|jrb|j|_|S dS )zAugment functools.update_wrapper() to work with objects with
    a ``__call__()`` method.

    :param fn:
      object with __call__ method

    r'   r(   r*   N)r:   r   r   r'   r(   r   r*   )wrapperrP   _fr   r   r   wrap_callable  s    



r  c                 C   s   d| kr|  dS d}g g}d}t| }||k r| | }|dkr|dkr|||d k r|| |d  dkr||d d |d7 }q|dN }n*|dkr|dkr|g  n|d | |d7 }q(dd |D S )a  Parse a dotted identifier with accommodation for quoted names.

    Includes support for SQL-style double quotes as a literal character.

    E.g.::

        >>> quoted_token_parser("name")
        ["name"]
        >>> quoted_token_parser("schema.name")
        ["schema", "name"]
        >>> quoted_token_parser('"Schema"."Name"')
        ['Schema', 'Name']
        >>> quoted_token_parser('"Schema"."Name""Foo"')
        ['Schema', 'Name""Foo']

    "ro   r   r   rp   c                 S   s   g | ]}d  |qS ) )r1   )r.   r   r   r   r   r   U  s     z'quoted_token_parser.<locals>.<listcomp>)ru   r   r;   )r!   r   r  idxlvcharr   r   r   quoted_token_parser,  s$    
$


r  c                    s   t    fdd}|S )Nc                    s:   | j d k	r| j pd}|r0t|fdd D }|| _ | S )Nr  c                    s   i | ]
}| qS r   r   )r.   paramrT  r   r   
<dictcomp>^  s      z8add_parameter_text.<locals>.decorate.<locals>.<dictcomp>)r*   inject_param_text)rP   ry   paramsrU  r   r   rk   [  s
    z$add_parameter_text.<locals>.decorate)r   r   )r  rU  rk   r   r  r   add_parameter_textX  s    
r  c                 C   sN   |  dd}t|dkr| S |\}}|ds@|d t| S t| S d S )N
r   r,   )ru   r   r   textwrapdedent)rU  Z
split_text	firstline	remainingr   r   r   _dedent_docstringe  s    
r  c                 C   s   t | pd} | d}t|d}|d r:|dd dd t|D }|dd |t|t|d  }|d| | ||d   }d|S )Nr  r  r   c                 S   s   g | ]\}}|  s|qS r   )rQ  )r.   r  liner   r   r   r   x  s      z)inject_docstring_text.<locals>.<listcomp>r   )	r  ru   r  r  r  r   minr   r1   )doctextZ
injecttextposlinesZinjectlinesZblanksZ
inject_posr   r   r   inject_docstring_textq  s    
r  c           
      C   s4  |   }g }d }|r*|d}|d krtd|}|r|d}||krdt|d d }|rtd|d }	|	rdt|	d }|||  }n| dr|d || |d d }nT|	 s|| || |d d }n(|
d	r|| ||d q|| qd|S )
Nr   z(\s+):param (?:\\\*\*?)?(.+?):r   r,   r   z(\s+)\Sz:param r  z::)
splitlinesr   r2   r  r|   r   lstripr   r;   rstripr   r1   )
r  Zinject_paramsZdoclinesr  Z	to_injectr  r   r  indentm2r   r   r   r    sD    








r  )N)FF)T)T)r   Nr   )NNr   N)NNN)F)TN)N)r  )Xr*   	functoolsr   r   rY   rF   r  r2   r   r  r   r  r  r   r   r   r   r   r   r5   r>   rO   rR   rl   r`   rz   r{   r   r   r   r   r_   r   r   r   r   r   r   r   r  r  r  r  r  r  r$  r.  r/  rS  rW  rY  r[  r^  rc  rk  rm  r	  rD  rv  r{  r~  rX  r  r'   rq   r  r  r  r  	text_typer  r   r  r  compileZ_SQLA_REZ_UNITTEST_REr  rt   ZNoneTyper  r  r  r  r  r  r  r  r   r   r   r   <module>   s   .	0*
+
6
S

H3    
?
V(
u

!G





,