B k[4@sddlmZddlZddlmZmZmZmZddlm Z ddl m Z m Z ddl ZGdddeZd d Zd d Zefd dZddZddZGdddeZddZGdddeZddZddZdS))warnN)ordering ambiguitiessuper_signatureAmbiguityWarning) expand_tuples)Variadic isvariadicc@seZdZdZdS)MDNotImplementedErrorz- A NotImplementedError for multiple dispatch N)__name__ __module__ __qualname____doc__rr:lib/python3.7/site-packages/multipledispatch/dispatcher.pyr sr cCstt|j|tdS)aC Raise warning when ambiguity is detected Parameters ---------- dispatcher : Dispatcher The dispatcher on which the ambiguity was detected ambiguities : set Set of type signature pairs that are ambiguous within this dispatcher See Also: Dispatcher.add warning_text N)r warning_textnamer)Z dispatcherrrrrambiguity_warn srcCstdtdS)z:Deprecated interface to temporarily disable ordering. z=halt_ordering is deprecated, you can safely remove this call.N)rDeprecationWarningrrrr halt_orderingsrcCstdtdS)z9Deprecated interface to temporarily resume ordering. zrestart_ordering is deprecated, if you would like to eagerly orderthe dispatchers, you should call the ``reorder()`` method on each dispatcher.N)rr) on_ambiguityrrrrestart_ordering'srccs|t|}t|}xf|D]$}t||}|Vt|st|}qWy t|}Wn&tk rpt|sftdVYnXdVdS)ajCheck if a set of input types matches a variadic signature. Notes ----- The algorithm is as follows: Initialize the current signature to the first in the sequence For each type in `types`: If the current signature is variadic If the type matches the signature yield True Else Try to get the next signature If no signatures are left we can't possibly have a match so yield False Else yield True if the type matches the current signature Get the next signature TFN)iternext issubclassr StopIterationAssertionError)typesfull_signatureZsigitersigtypZmatchesrrrvariadic_signature_matches_iter2s      r"cCs|sttt||S)N)rallr")rrrrrvariadic_signature_matches\sr$c@seZdZdZdZd*ddZddZedd Zed d Z d d Z e ddZ e fddZddZddZeZddZddZddZddZddZe d d!Zd"d#Zd$d%Zd&d'Zd(d)ZdS)+ DispatcheraW Dispatch methods based on type signature Use ``dispatch`` to add implementations Examples -------- >>> from multipledispatch import dispatch >>> @dispatch(int) ... def f(x): ... return x + 1 >>> @dispatch(float) ... def f(x): ... return x - 1 >>> f(3) 4 >>> f(3.0) 2.0 )r rfuncs _ordering_cachedocNcCs"||_|_i|_||_i|_dS)N)rr r&r)r()selfrr)rrr__init__zs zDispatcher.__init__csfdd}|S)a register dispatcher with new implementation >>> f = Dispatcher('f') >>> @f.register(int) ... def inc(x): ... return x + 1 >>> @f.register(float) ... def dec(x): ... return x - 1 >>> @f.register(list) ... @f.register(tuple) ... def reverse(x): ... return x[::-1] >>> f(1) 2 >>> f(1.0) 0.0 >>> f([1, 2, 3]) [3, 2, 1] csj|f|S)N)add)func)kwargsr*rrr_szDispatcher.register.._r)r*rr.r/r)r.r*rrregisterszDispatcher.registercCs"ttdrt|}|jSdS)N signature)hasattrinspectr1 parametersvalues)clsr-r rrrget_func_paramss  zDispatcher.get_func_paramscsV||}|rRtjfdd|D}tdd|D}tfdd|DrR|SdS)z; get annotations of function positional parameters c3s$|]}|jjjfkr|VqdS)N)ZkindZPOSITIONAL_ONLYZPOSITIONAL_OR_KEYWORD).0param) Parameterrr sz2Dispatcher.get_func_annotations..css|] }|jVqdS)N)Z annotation)r8r9rrrr;sc3s|]}|jk VqdS)N)empty)r8ann)r:rrr;sN)r7r3r:tupler#)r6r-Zparams annotationsr)r:rget_func_annotationss  zDispatcher.get_func_annotationsc Cs*|s||}|r|}tdd|DrJxt|D]}|||q2WdSg}xt|ddD]\}}t|ttfsddd|D}t d|||j ft|tr|t |krt d t |dkrt d | t |d q\| |q\W||jt|<|jy|`Wntk r$YnXdS) aL Add new types/method pair to dispatcher >>> D = Dispatcher('add') >>> D.add((int, int), lambda x, y: x + y) >>> D.add((float, float), lambda x, y: x + y) >>> D(1, 2) 3 >>> D(1, 2.0) Traceback (most recent call last): ... NotImplementedError: Could not find signature for add: When ``add`` detects a warning it calls the ``on_ambiguity`` callback with a dispatcher/itself, and a set of ambiguous type signature pairs as inputs. See ``ambiguity_warn`` for an example. css|]}t|tVqdS)N) isinstancer>)r8r!rrrr;sz!Dispatcher.add..Nr)startz, css&|]}t|tr|jnt|VqdS)N)rAtyper str)r8crrrr;szDTried to dispatch on non-type: %s In signature: <%s> In function: %sz+Variadic signature must be the last elementzVariadic signature must contain exactly one element. To use a variadic union type place the desired types inside of a tuple, e.g., [(int, str)]r)r@anyrr, enumeraterArClistjoin TypeErrorrlenappendr r&r>r(clearr'AttributeError) r*r1r-r?ZtypsZ new_signatureindexr!Zstr_sigrrrr,s<       zDispatcher.addcCs$y|jStk r|SXdS)N)r'rNreorder)r*rrrrszDispatcher.orderingcCs,t|j|_}t|j}|r(||||S)N)rr&r'r)r*rZodambrrrrPs   zDispatcher.reorderc Ostdd|D}y|j|}WnBtk rb|j|}|sTtd|jt|f||j|<YnXy |||Stk r|j|}t |x,|D]$}y |||Stk rYqXqWtd|jt|fYnXdS)NcSsg|] }t|qSr)rC)r8argrrr sz'Dispatcher.__call__..z%Could not find signature for %s: <%s>zFMatching functions for %s: <%s> found, but none completed successfully) r>r(KeyErrordispatchNotImplementedErrorr str_signaturer dispatch_iterr)r*argsr.rr-r&rrr__call__ s.      zDispatcher.__call__cCs d|jS)Nz)r)r*rrr__str__(szDispatcher.__str__cGs<||jkr|j|Syt|j|Stk r6dSXdS)aQDeterimine appropriate implementation for this type signature This method is internal. Users should call this object as a function. Implementation resolution occurs within the ``__call__`` method. >>> from multipledispatch import dispatch >>> @dispatch(int) ... def inc(x): ... return x + 1 >>> implementation = inc.dispatch(int) >>> implementation(3) 4 >>> print(inc.dispatch(float)) None See Also: ``multipledispatch.conflict`` - module to determine resolution order N)r&rrXr)r*rrrrrU,s   zDispatcher.dispatchcgsxt|}xj|jD]`}t||krBttt||rB|j|}|Vqt|rt|drt||r|j|}|VqWdS)N)rKrr#maprr&r r$)r*rnr1resultrrrrXJs    zDispatcher.dispatch_itercCstdt|j|S)z Deterimine appropriate implementation for this type signature .. deprecated:: 0.4.4 Use ``dispatch(*types)`` instead z-resolve() is deprecated, use dispatch(*types))rrrU)r*rrrrresolveVszDispatcher.resolvecCs|j|jdS)N)rr&)rr&)r*rrr __getstate__aszDispatcher.__getstate__cCs,|d|_|d|_t|j|_t|_dS)Nrr&)rr&rr'dictr()r*drrr __setstate__es   zDispatcher.__setstate__cCsd|jg}|jr||jg}xp|jdddD]\}|j|}|jrdt|}|dt|d7}||j7}||q4|t|q4W|r|dd |d |S) NzMultiply dispatched method: %sr\z Inputs: <%s> - zOther signatures: z z ) rr)rLrr&rrWrKstriprI)r*Zdocsotherr r-srrrrks     zDispatcher.__doc__cGs|jtt|jS)N)rUr]rCr)r*rYrrr_helpszDispatcher._helpcOst|j|dS)z: Print docstring for the function corresponding to inputs N)printrj)r*rYr.rrrhelpszDispatcher.helpcGs$|jtt|}|stdt|S)NzNo function found)rUr]rCrJsource)r*rYr-rrr_sourceszDispatcher._sourcecOst|j|dS)z< Print source code for the function corresponding to inputs N)rkrn)r*rYr.rrrrmszDispatcher.source)N)r r rr __slots__r+r0 classmethodr7r@r,propertyrrrPrZr[__repr__rUrXr`rardrjrlrnrmrrrrr%bs,   B     r%cCs dt|}|t|}|S)Nz File: %s )r3Z getsourcefileZ getsource)r-rirrrrmsrmc@s0eZdZdZdZeddZddZddZd S) MethodDispatcherzP Dispatch methods based on type signature See Also: Dispatcher )objr6cCs,ttdr(t|}t|jddSdS)Nr1r)r2r3r1itlislicer4r5)r6r-r rrrr7s  z MethodDispatcher.get_func_paramscCs||_||_|S)N)rtr6)r*instanceownerrrr__get__szMethodDispatcher.__get__cOsHtdd|D}|j|}|s6td|jt|f||jf||S)NcSsg|] }t|qSr)rC)r8rRrrrrSsz-MethodDispatcher.__call__..z%Could not find signature for %s: <%s>)r>rUrVrrWrt)r*rYr.rr-rrrrZs  zMethodDispatcher.__call__N) r r rrrorpr7ryrZrrrrrss  rscCsddd|DS)zc String representation of type signature >>> str_signature((int, float)) 'int, float' z, css|] }|jVqdS)N)r )r8r6rrrr;sz str_signature..)rI)r rrrrWsrWcsfd}|d7}x,|D]$}|dddd|Dd7}qW|d7}|d fd d |D7}|S) z! The text for ambiguity warnings z. Ambiguities exist in dispatched function %s z;The following signatures may result in ambiguous behavior:  z, css|]}dt|dVqdS)[]N)rW)r8rirrrr;szwarning_text..rfz, Consider making the following additions: z cs$g|]}dtt|dqS)z @dispatch(z ) def %s(...))rWr)r8ri)rrrrSsz warning_text..)rI)rrQtextZpairr)rrrs " r)warningsrr3ZconflictrrrrZutilsrZvariadicr r itertoolsrurVr rrrr"r$objectr%rmrsrWrrrrrs$   *4