o Zh"6@sddlZddlZddlmZddlmZddlmZm Z m Z m Z ddl m Z ddlmZmZgdZGd d d eZd d Zed edddZededefddZddZddZGdddZddZGdddeZddZd d!ZdS)"N) deprecated)warn) ambiguitiesAmbiguityWarningorderingsuper_signature) expand_tuples) isvariadicVariadic) MDNotImplementedErrorambiguity_warn halt_orderingrestart_orderingvariadic_signature_matches_itervariadic_signature_matches DispatchersourceMethodDispatcher str_signature warning_textc@seZdZdZdS)r z+A NotImplementedError for multiple dispatchN)__name__ __module__ __qualname____doc__rrl/var/www/auris/lib/python3.10/site-packages/torch/fx/experimental/unification/multipledispatch/dispatcher.pyr sr cCstt|j|tdS)a@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)rrnamer) dispatcherrrrrr s r z?`halt_ordering` is deprecated, you can safely remove this call.categorycCdS)z5Deprecated interface to temporarily disable ordering.Nrrrrrr.rz`restart_ordering` is deprecated, if you would like to eagerly order the dispatchers, you should call the `reorder()` method on each dispatcher.cCr!)z4Deprecated interface to temporarily resume ordering.Nr) on_ambiguityrrrr6r"rccszt|}t|}|D]}t||}|Vt|st|}q zt|}Wnty7t|s1JdVYdSwdVdS)agCheck 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 StopIteration)typesfull_signatureZsigitersigtypmatchesrrrr?s       rcCs|sJtt||SN)allr)r(r)rrrrfsrc@seZdZdZdZd,ddZddZedd Zed d Z d d Z e ddZ e fddZddZddZeZddZddZededddZddZd d!Ze d"d#Zd$d%Zd&d'Zd(d)Zd*d+ZdS)-ra~Dispatch methods based on type signature Use ``dispatch`` to add implementations Examples -------- >>> # xdoctest: +SKIP("bad import name") >>> 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 )rrfuncs _ordering_cachedocNcCs"||_|_i|_||_i|_dSr-)rrr/r2r1)selfrr2rrr__init__s  zDispatcher.__init__csfdd}|S)aregister dispatcher with new implementation >>> # xdoctest: +SKIP >>> 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|fi|Sr-)add)funckwargsr3r(rr_dfsz Dispatcher.register.._dfr)r3r(r8r9rr7rregisterszDispatcher.registercCs"ttdrt|}|jSdS)N signature)hasattrinspectr; parametersvaluesclsr6r*rrrget_func_paramss   zDispatcher.get_func_paramscsZ||}|r)tjfdd|D}tdd|D}tfdd|Dr+|SdSdS)z1get annotations of function positional parametersc3s&|]}|jjjfvr|VqdSr-)kindPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORD.0param Parameterrr s z2Dispatcher.get_func_annotations..cs|]}|jVqdSr-) annotationrFrrrrKc3s|]}|juVqdSr-)empty)rGannrIrrrKN)rBr=rJtupler.)rAr6params annotationsrrIrget_func_annotationss   zDispatcher.get_func_annotationsc Cs&|s ||}|r |}tdd|Dr#t|D]}|||qdSg}t|ddD]K\}}t|ttfsNddd|D}t d|d |d |j t|trq|t |kr]t d t |dkrgt d | t |d q+| |q+||jt|<|jz|`WdStyYdSw)axAdd new types/method pair to dispatcher >>> # xdoctest: +SKIP >>> 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|tVqdSr-) isinstancerR)rGr+rrrrKrQz!Dispatcher.add..Nr)start, css(|]}t|tr |jnt|VqdSr-)rVtyperstr)rGcrrrrKs zTried to dispatch on non-type: z In signature: In function: z+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)rUanyr r5 enumeraterVrYlistjoin TypeErrorrlenappendr r/rRr1clearr0AttributeError) r3r;r6rTZtypsZ new_signatureindexr+Zstr_sigrrrr5sJ          zDispatcher.addcCs$z|jWSty|YSwr-)r0rdreorderr3rrrrs   zDispatcher.orderingcCs,t|j|_}t|j}|r||||Sr-)rr/r0r)r3r#Zodambrrrrfs   zDispatcher.reorderc Ostdd|D}z|j|}Wn-ty=}z!|j|}|s.td|jdt|d|||j|<WYd}~nd}~wwz||i|WSty}z6|j|}t ||D]}z||i|WWYd}~StytYqYwtd|jdt|d|d}~ww)NcSg|]}t|qSrrYrGargrrr z'Dispatcher.__call__..Could not find signature for : <>zMatching functions for z(> found, but none completed successfully) rRr1KeyErrordispatchNotImplementedErrorrrr dispatch_iterr%)r3argsr8r(r6er/rrr__call__ sH    zDispatcher.__call__cCsd|jdS)Nz >> # xdoctest: +SKIP >>> 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/r%rur'r3r(rrrrs,s   zDispatcher.dispatchcgsvt|}|jD]0}t||kr!ttt||r!|j|}|Vqt|r8t|dr8t||r8|j|}|VqdS)N)rarr.mapr&r/r r)r3r(nr;resultrrrruFs    zDispatcher.dispatch_iterz1`resolve()` is deprecated, use `dispatch(*types)`rcCs |j|S)zDetermine appropriate implementation for this type signature .. deprecated:: 0.4.4 Use ``dispatch(*types)`` instead )rsr|rrrresolveQs zDispatcher.resolvecCs|j|jdS)Nrr/rrgrrr __getstate__[r{zDispatcher.__getstate__cCs*|d|_|d|_t|j|_i|_dS)Nrr/)rr/rr0r1)r3drrr __setstate__^s    zDispatcher.__setstate__cCsd|jg}|jr||jg}|jdddD]0}|j|}|jrCdt|d}|dt|d7}||j7}||q|t|q|rW|dd |d |S) NzMultiply dispatched method: r}z Inputs: - zOther signatures: z  ) rr2rbrr/rrrastripr_)r3docsotherr*r6srrrrds    zDispatcher.__doc__cGs|jtt|jSr-)rsr~rYr)r3rvrrr_help{szDispatcher._helpcOt|j|dS)z8Print docstring for the function corresponding to inputsN)printrr3rvr8rrrhelp~zDispatcher.helpcGs$|jtt|}|stdt|S)NzNo function found)rsr~rYr`r)r3rvr6rrr_sourceszDispatcher._sourcecOr)z:Print source code for the function corresponding to inputsN)rrrrrrrrzDispatcher.sourcer-)rrrr __slots__r4r: classmethodrBrUr5propertyrr rfrxrz__repr__rsrur FutureWarningrrrrrrrrrrrrls<   @      rcCs$dt|d}|t|}|S)NzFile: r)r= getsourcefile getsource)r6rrrrrsrc@s0eZdZdZdZeddZddZddZd S) rzNDispatch methods based on type signature See Also: Dispatcher objrAcCs,ttdrt|}t|jddSdS)Nr;r)r<r=r;itlislicer>r?r@rrrrBs  z MethodDispatcher.get_func_paramscCs||_||_|Sr-r)r3instanceownerrrr__get__szMethodDispatcher.__get__cOsTtdd|D}|j|}|std|jdt|d||jg|Ri|S)NcSrirrjrkrrrrmrnz-MethodDispatcher.__call__..rorprq)rRrsrtrrr)r3rvr8r(r6rrrrxs zMethodDispatcher.__call__N) rrrrrrrBrrxrrrrrs  rcCsddd|DS)zaString representation of type signature >>> str_signature((int, float)) 'int, float' rXcsrLr-)r)rGrArrrrKrNz str_signature..r_)r*rrrrsrcsfdd}|d7}|D]}|dddd|Dd7}q |d 7}|dfd d |D7}|S) zThe text for ambiguity warningsz* Ambiguities exist in dispatched function rz;The following signatures may result in ambiguous behavior:  rXcss |] }dt|dVqdS)[]N)rrGrrrrrKszwarning_text..rz, Consider making the following additions: cs(g|]}dtt|ddqS)z @dispatch(z) def z(...))rrrryrrrmsz warning_text..r)rrhtextpairrryrrs " r)r= itertoolsrZtyping_extensionsrwarningsrconflictrrrrutilsr Zvariadicr r __all__rtr r rrrrrrrrrrrrrrs:    '#