U yh6 @sddlmZddlZddlmZddlmZmZmZm Z ddl m Z ddl m Z mZddlZdd d d d d dddddg ZGdddeZdd Zededdd Zededefdd Zdd Zdd ZGdddZddZGdddeZddZd dZdS)!)warnN) deprecated)ordering ambiguitiessuper_signatureAmbiguityWarning) expand_tuples)Variadic isvariadicMDNotImplementedErrorambiguity_warn halt_orderingrestart_orderingvariadic_signature_matches_itervariadic_signature_matches DispatchersourceMethodDispatcher str_signature warning_textc@seZdZdZdS)r z- A NotImplementedError for multiple dispatch N)__name__ __module__ __qualname____doc__rro/var/www/html/venv/lib/python3.8/site-packages/torch/fx/experimental/unification/multipledispatch/dispatcher.pyr scCstt|j|tdS)aA 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 z?`halt_ordering` is deprecated, you can safely remove this call.categorycCsdS)z5Deprecated interface to temporarily disable ordering.Nrrrrrr sz`restart_ordering` is deprecated, if you would like to eagerly order the dispatchers, you should call the `reorder()` method on each dispatcher.cCsdS)z4Deprecated interface to temporarily resume ordering.Nr) on_ambiguityrrrr(sccsxt|}t|}|D]$}t||}|Vt|st|}qz t|}Wn&tk rlt|sbtdVYnXdVdS)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 StopIterationAssertionError)typesfull_signatureZsigitersigtypmatchesrrrr1s     cCs|sttt||SN)r&allr)r'r(rrrrXsc@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.r1r0)selfrr1rrr__init__rs zDispatcher.__init__csfdd}|S)a register 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|f|Sr,)add)funckwargsr2r'rr_dfsz Dispatcher.register.._dfr)r2r'r7r8rr6rregisteryszDispatcher.registercCs"ttdrt|}|jSdS)N signature)hasattrinspectr: parametersvaluesclsr5r)rrrget_func_paramss  zDispatcher.get_func_paramscsV||}|rRtjfdd|D}tdd|D}tfdd|DrR|SdS)z; get annotations of function positional parameters c3s$|]}|jjjfkr|VqdSr,)kindPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORD.0param Parameterrr sz2Dispatcher.get_func_annotations..css|] }|jVqdSr,) annotationrErrrrJsc3s|]}|jk VqdSr,)empty)rFannrHrrrJsN)rAr<rItupler-)r@r5params annotationsrrHrget_func_annotationss zDispatcher.get_func_annotationsc Cs*|s||}|r|}tdd|DrFt|D]}|||q0dSg}t|ddD]\}}t|ttfsddd|D}t d|d |d |j t|tr|t |krt d t |dkrt d | t |d qV| |qV||jt|<|jz|`Wntk r$YnXdS)ay Add 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,) isinstancerN)rFr*rrrrJsz!Dispatcher.add..Nr)start, css&|]}t|tr|jnt|VqdSr,)rRtyperstr)rFcrrrrJszTried 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)rQanyr r4 enumeraterRrUlistjoin TypeErrorrlenappendr r.rNr0clearr/AttributeError) r2r:r5rPZtypsZ new_signatureindexr*Zstr_sigrrrr4s@        zDispatcher.addcCs*z|jWStk r$|YSXdSr,)r/r`reorderr2rrrrszDispatcher.orderingcCs,t|j|_}t|j}|r(||||Sr,)rr.r/r)r2r!Zodambrrrrbs   zDispatcher.reorderc Ostdd|D}z|j|}WnXtk rx}z:|j|}|s^td|jdt|d|||j|<W5d}~XYnXz |||WStk r}zl|j|}t ||D]2}z|||WWY:Stk rYqXqtd|jdt|d|W5d}~XYnXdS)NcSsg|] }t|qSrrUrFargrrr sz'Dispatcher.__call__..Could not find signature for : <>zMatching functions for z(> found, but none completed successfully) rNr0KeyErrordispatchNotImplementedErrorrrr dispatch_iterr#)r2argsr7r'r5er.rrr__call__s6   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#ror%r2r'rrrrms   zDispatcher.dispatchcgstt|}|jD]`}t||kr@ttt||r@|j|}|Vqt|rt|drt||r|j|}|VqdS)N)r]rr-mapr$r.r r)r2r'nr:resultrrrro2s    zDispatcher.dispatch_iterz1`resolve()` is deprecated, use `dispatch(*types)`rcCs |j|S)z Determine appropriate implementation for this type signature .. deprecated:: 0.4.4 Use ``dispatch(*types)`` instead )rmrurrrresolve>szDispatcher.resolvecCs|j|jdS)Nrr.r{rcrrr __getstate__FszDispatcher.__getstate__cCs*|d|_|d|_t|j|_i|_dS)Nrr.)rr.rr/r0)r2drrr __setstate__Js   zDispatcher.__setstate__cCsd|jg}|jr ||jg}|jdddD]`}|j|}|jrdt|d}|dt|d7}||j7}||q4|t|q4|r|dd |d |S) NzMultiply dispatched method: rvz Inputs: - zOther signatures: z  ) rr1r^rr.rrr]stripr[)r2docsotherr)r5srrrrPs   zDispatcher.__doc__cGs|jtt|jSr,)rmrwrUr)r2rprrr_helpgszDispatcher._helpcOst|j|dS)z: Print docstring for the function corresponding to inputs N)printrr2rpr7rrrhelpjszDispatcher.helpcGs$|jtt|}|stdt|S)NzNo function found)rmrwrUr\r)r2rpr5rrr_sourcenszDispatcher._sourcecOst|j|dS)z< Print source code for the function corresponding to inputs N)rrrrrrrtszDispatcher.source)N)rrrr __slots__r3r9 classmethodrArQr4propertyrr rbrrrt__repr__rmror FutureWarningrzr|r~rrrrrrrrr^s6   ?     cCs$dt|d}|t|}|S)NzFile: r)r< getsourcefile getsource)r5rrrrrysc@s0eZdZdZdZeddZddZddZd S) rzO Dispatch methods based on type signature See Also: Dispatcher objr@cCs,ttdr(t|}t|jddSdS)Nr:r)r;r<r:itlislicer=r>r?rrrrAs  z MethodDispatcher.get_func_paramscCs||_||_|Sr,r)r2instanceownerrrr__get__szMethodDispatcher.__get__cOsNtdd|D}|j|}|s.rirjrk)rNrmrnrrr)r2rpr7r'r5rrrrrs  zMethodDispatcher.__call__N) rrrrrrrArrrrrrrrs  cCsddd|DS)zb String representation of type signature >>> str_signature((int, float)) 'int, float' rTcss|] }|jVqdSr,)r)rFr@rrrrJsz str_signature..r[)r)rrrrscsfdd}|d7}|D]$}|dddd|Dd7}q|d 7}|dfd d |D7}|S) z! The text for ambiguity warnings z* Ambiguities exist in dispatched function rz;The following signatures may result in ambiguous behavior:  rTcss|]}dt|dVqdS)[]N)rrFrrrrrJszwarning_text..rz, Consider making the following additions: cs(g|] }dtt|ddqS)z @dispatch(z) def z(...))rrrrsrrrhs z warning_text..r)rrdtextpairrrsrrs  )warningsrr<typing_extensionsrconflictrrrrutilsr Zvariadicr r itertoolsr__all__rnr r rrrrrrrrrrrrrrsF     '