�
���cc @` s� d d l m Z d d l m Z d d l m Z d d l m Z d d g Z d d l m Z d d l m Z m
Z
m Z m Z d
� Z
d d � Z d � Z d
� Z d � Z d � Z d � Z d e f d � � YZ d S( i ( t absolute_import( t division( t print_function( t unicode_literalsu singledispatchu singledispatchmethod( t WeakKeyDictionaryi ( t MappingProxyTypet get_cache_tokent get_type_hintst update_wrapperc C` s� g } x� t r� g | D] } | r | ^ q } | s8 | SxD | D]< } | d } x) | D] } | | d k rV d } PqV qV WPq? W| d k r� t d � � n | j | � x( | D] } | d | k r� | d =q� q� Wq Wd S( u� Merges MROs in *sequences* to a single MRO using the C3 algorithm.
Adapted from http://www.python.org/download/releases/2.3/mro/.
i i u Inconsistent hierarchyN( t Truet Nonet RuntimeErrort append( t sequencest resultt st s1t candidatet s2t seq( ( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt _c3_merge s$
c
` s� xO t t | j � � D]2 \ } � t � d � r t | j � | } Pq q Wd } | rd t | � n g } t | j | � } g } t | j | � } xM | D]E � t | � � r� t � f d � | j D� � r� | j � � q� q� Wx | D] � | j � � q� Wg | D] � t
� d | �^ q } g | D] � t
� d | �^ q0} g | D] � t
� d | �^ qU} t | g g | | | | g | g | g � S( u� Computes the method resolution order using extended C3 linearization.
If no *abcs* are given, the algorithm works exactly like the built-in C3
linearization used for method resolution.
If given, *abcs* is a list of abstract base classes that should be inserted
into the resulting MRO. Unrelated ABCs are ignored and don't end up in the
result. The algorithm inserts ABCs where their functionality is introduced,
i.e. issubclass(cls, abc) returns True for the class itself but returns
False for all its direct base classes. Implicit ABCs for a given class
(either registered or inferred from the presence of a special method like
__len__) are inserted directly after the last ABC explicitly listed in the
MRO of said class. If two implicit ABCs end up next to each other in the
resulting MRO, their ordering depends on the order of types in *abcs*.
u __abstractmethods__i c 3` s | ] } t | � � Vq d S( N( t
issubclass( t .0t b( t base( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pys <genexpr>K s t abcs( t enumeratet reversedt __bases__t hasattrt lent listR t anyR t removet _c3_mroR (
t clsR t it boundaryt explicit_basest abstract_basest other_basest explicit_c3_mrost abstract_c3_mrost
other_c3_mros( ( R s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyR" . s( "
%%%c ` s� t � j � � � � f d � } g � D] } | | � r( | ^ q( � � f d � } g � D] } | | � s\ | ^ q\ � t � � } g } x� � D]� } g } xj t t | j � � D]S } | � k r� t � | � r� | j g | j D] }
|
| k r� |
^ q� � q� q� W| s%| j | � q� n | j d t d t � x; | D]3 } x* | D]" } | | k rO| j | � qOqOWqBWq� Wt
� d | �S( u� Calculates the method resolution order for a given class *cls*.
Includes relevant abstract base classes (with their respective bases) from
the *types* iterable. Uses a modified C3 linearization algorithm.
c ` s( | � k o' t | d � o' t � | � S( Nu __mro__( R R ( t typ( t basesR# ( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt
is_relatedd s c ` s4 x- � D]% } | | k r | | j k r t Sq Wt S( N( t __mro__R t False( R, t other( t types( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt is_strict_basej s
t keyt reverseR ( t setR/ t filtert _safet __subclasses__R R t sortR R R" ( R# R2 R. t nR3 t type_sett mroR, t foundt subR t subcls( ( R- R# R2 s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt _compose_mro[ s* %%
6
c C` s t | d d � S( uF
Return if the class is safe for testing as subclass. Ref #2.
u
__origin__N( t getattrR
( t class_( ( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyR8 � s c C` s� t | | j � � } d } x� | D]� } | d k r� | | k r� | | j k r� | | j k r� t | | � r� t d j | | � � � n Pn | | k r" | } q" q" W| j | � S( u^ Returns the best matching implementation from *registry* for type *cls*.
Where there is no registered implementation for a specific type, its method
resolution order is used to find a more generic implementation.
Note: if *registry* does not contain an implementation for the base
*object* type, this function may return None.
u Ambiguous dispatch: {0} or {1}N( RA t keysR
R/ R R t formatt get( R# t registryR= t matcht t( ( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt
_find_impl� s
c C` sK y$ d d l m } t | | � } Wn t k
rF t | t � } n X| S( u� Determine if an annotation is valid for registration.
An annotation is considered valid for use in registration if it is an
instance of ``type`` and not a generic type from ``typing``.
i ( t GenericMeta( t typingRK t
isinstancet ImportErrort type( t
annotationRK t valid( ( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt _validate_annotation� s
c ` s� i � t � � d � � d � _ � � � f d � � d � � � � f d � � � � f d � } t | d d � � | � t <� | _ � | _ t � � | _ � j | _
t | | � | S( uk Single-dispatch generic function decorator.
Transforms a function into a generic function, which can have different
behaviours depending upon the type of its first argument. The decorated
function acts as the default implementation, and additional
implementations can be registered using the register() attribute of the
generic function.
c S` s d S( N( ( ( ( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt ns� t c ` s� � j d k r@ t � } � j | k r@ � j � | � _ q@ n y � | } WnL t k
r� y � | } Wn t k
r� t | � � } n X| � | <n X| S( u� generic_func.dispatch(cls) -> <function implementation>
Runs the dispatch algorithm to return the best available implementation
for the given *cls* registered on *generic_func*.
N( t cache_tokenR
R t cleart KeyErrorRJ ( R# t
current_tokent impl( t dispatch_cacheRS RG ( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt dispatch� s
c ` s� | d k r� t � t � r+ � � f d � St � d i � } | s^ t d j t � � � � n � } t t t | � j
� � � \ } � t � � s� t d j t � � � � q� n | � � <� j d k r� t
� d � r� t � � _ n � j � | S( u� generic_func.register(cls, func) -> func
Registers a new implementation for the given *cls* on a *generic_func*.
c ` s
� � | � S( N( ( t f( R# t register( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt <lambda>� RT u __annotations__u� Invalid first argument to `register()`: {cls!r}. Use either `@register(some_class)` or plain `@register` on an annotated function.u; Invalid annotation for {argname!r}. {cls!r} is not a class.u __abstractmethods__N( R
RM RO RB t TypeErrorRE t localst nextt iterR t itemsRR RU R R RV ( R# t funct annt argname( RZ RS R] RG ( R# s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyR] � s& $
c ` s8 | s t d j � � � � n � | d j � | | � S( Nu+ {0} requires at least 1 positional argumenti ( R_ RE t __class__( t argst kw( R[ t funcname( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt wrapper� s u __name__u singledispatch functionN( R R
RU RB t objectR] R[ R RG RV t _clear_cacheR ( Rd Rk ( ( R[ RZ Rj RS R] RG s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt singledispatch� s
t singledispatchmethodc B` s> e Z d Z d � Z d d � Z d d � Z e d � � Z RS( u� Single-dispatch generic method descriptor.
Supports wrapping existing descriptors and handles non-descriptor
callables as instance methods.
c C` sQ t | � r5 t | d � r5 t d j | � � � n t | � | _ | | _ d S( Nu __get__u$ {!r} is not callable or a descriptor( t callableR R_ RE Rn t
dispatcherRd ( t selfRd ( ( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt __init__ s c C` s | j j | d | �S( u� generic_method.register(cls, func) -> func
Registers a new implementation for the given *cls* on a *generic_method*.
Rd ( Rq R] ( Rr R# t method( ( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyR] s c ` sA � � � f d � } � j | _ � j | _ t | � j � | S( Nc ` s2 � j j | d j � } | j � � � | | � S( Ni ( Rq R[ Rg t __get__( Rh t kwargsRt ( R# t objRr ( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt _method! s ( t __isabstractmethod__R] R Rd ( Rr Rw R# Rx ( ( R# Rw Rr s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyRu s
c C` s t | j d t � S( Nu __isabstractmethod__( RB Rd R0 ( Rr ( ( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyRy * s N( t __name__t
__module__t __doc__Rs R
R] Ru t propertyRy ( ( ( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyRo s
N( t
__future__R R R R t __all__t weakrefR t helpersR R R R R R
R" RA R8 RJ RR Rn Rl Ro ( ( ( s; /usr/lib/python2.7/site-packages/singledispatch/__init__.pyt <module> s " - * T