U Jc16 @sddlmZddlZddlmZmZmZmZddlm Z ddl m Z m Z ddl Zddd d d d d ddddg ZGdddeZddZdd Zefdd Zdd Zdd ZGdd d eZddZGdddeZddZddZdS))warnN)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__rra/tmp/pip-unpacked-wheel-gikjz4vx/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 cCstdtdS)z:Deprecated interface to temporarily disable ordering. z=halt_ordering is deprecated, you can safely remove this call.NrDeprecationWarningrrrrr scCstdtdS)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.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_signatureZsigitersigtypmatchesrrrr2s     cCs|sttt||SN)r%allr)r&r'rrrrYsc@seZdZdZdZd*ddZddZedd Zed d Z d d Z e ddZ e fddZddZddZeZddZddZddZddZddZe 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-r0r/)selfrr0rrr__init__ss 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|Sr+)add)funckwargsr1r&rr_dfsz Dispatcher.register.._dfr)r1r&r6r7rr5rregisterzszDispatcher.registercCs"ttdrt|}|jSdS)N signature)hasattrinspectr9 parametersvaluesclsr4r(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+) annotationrDrrrrIsc3s|]}|jk VqdSr+)empty)rEannrGrrrIsN)r@r;rHtupler,)r?r4params annotationsrrGrget_func_annotationss zDispatcher.get_func_annotationsc Cs"|s||}|r|}tdd|DrFt|D]}|||q0dSg}t|ddD]\}}t|ttfsddd|D}t d|||j ft|tr|t |krt d t |dkrt d | t |d qV| |qV||jt|<|jz|`Wntk rYnXdS) a[ 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|tVqdSr+) isinstancerM)rEr)rrrrIsz!Dispatcher.add..Nr)start, css&|]}t|tr|jnt|VqdSr+)rQtyperstr)rEcrrrrIszDTried 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)rPanyrr3 enumeraterQrTlistjoin TypeErrorrlenappendr r-rMr/clearr.AttributeError) r1r9r4rOZtypsZ new_signatureindexr)Zstr_sigrrrr3sD         zDispatcher.addcCs*z|jWStk r$|YSXdSr+)r.r_reorderr1rrrrszDispatcher.orderingcCs,t|j|_}t|j}|r(||||Sr+)rr-r.r)r1r Zodambrrrras   zDispatcher.reorderc Ostdd|D}z|j|}WnBtk rb|j|}|sTtd|jt|f||j|<YnXz |||WStk r|j|}t ||D].}z|||WYStk rYqXqtd|jt|fYnXdS)NcSsg|] }t|qSrrTrEargrrr sz'Dispatcher.__call__..%Could not find signature for %s: <%s>zFMatching functions for %s: <%s> found, but none completed successfully) rMr/KeyErrordispatchNotImplementedErrorrrr dispatch_iterr")r1argsr6r&r4r-rrr__call__s:    zDispatcher.__call__cCs d|jS)Nzrrbrrr__str__szDispatcher.__str__cGs@||jkr|j|Szt|j|WStk r:YdSXdS)ajDeterimine 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. >>> # 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"rlr$r1r&rrrrjs   zDispatcher.dispatchcgstt|}|jD]`}t||kr@ttt||r@|j|}|Vqt|rt|drt||r|j|}|VqdS)N)r\rr,mapr#r-r r)r1r&nr9resultrrrrl4s    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))rrrjrqrrrresolve@szDispatcher.resolvecCs|j|jdS)Nrr-rwrbrrr __getstate__JszDispatcher.__getstate__cCs*|d|_|d|_t|j|_i|_dS)Nrr-)rr-rr.r/)r1drrr __setstate__Ns   zDispatcher.__setstate__cCsd|jg}|jr||jg}|jdddD]\}|j|}|jrdt|}|dt|d7}||j7}||q2|t|q2|r|dd |d |S) NzMultiply dispatched method: %srrz Inputs: <%s> - zOther signatures: z  ) rr0r]rr-rrr\striprZ)r1Zdocsotherr(r4srrrrTs     zDispatcher.__doc__cGs|jtt|jSr+)rjrsrTr)r1rmrrr_helpkszDispatcher._helpcOst|j|dS)z: Print docstring for the function corresponding to inputs N)printrr1rmr6rrrhelpnszDispatcher.helpcGs$|jtt|}|stdt|S)NzNo function found)rjrsrTr[r)r1rmr4rrr_sourcerszDispatcher._sourcecOst|j|dS)z< Print source code for the function corresponding to inputs N)rrrrrrrxszDispatcher.source)N)rrrr __slots__r2r8 classmethodr@rPr3propertyrr rarnrp__repr__rjrlrvrxrzrrrrrrrrr_s4   ?     cCs dt|}|t|}|S)Nz File: %s )r; getsourcefile getsource)r4rrrrr}sc@s0eZdZdZdZeddZddZddZd S) rzO Dispatch methods based on type signature See Also: Dispatcher objr?cCs,ttdr(t|}t|jddSdS)Nr9r)r:r;r9itlislicer<r=r>rrrr@s  z MethodDispatcher.get_func_paramscCs||_||_|Sr+r)r1instanceownerrrr__get__szMethodDispatcher.__get__cOsHtdd|D}|j|}|s6td|jt|f||jf||S)NcSsg|] }t|qSrrdrerrrrgsz-MethodDispatcher.__call__..rh)rMrjrkrrr)r1rmr6r&r4rrrrns  zMethodDispatcher.__call__N) rrrrrrr@rrnrrrrrs  cCsddd|DS)zb String representation of type signature >>> str_signature((int, float)) 'int, float' rScss|] }|jVqdSr+)r)rEr?rrrrIsz str_signature..rZ)r(rrrrscsbd}|d7}|D]$}|dddd|Dd7}q|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:  rScss|]}dt|dVqdS)[]N)rrErrrrrIszwarning_text..r|z, Consider making the following additions: r}cs$g|]}dtt|dqS)z @dispatch(z ) def %s(...))rrrrorrrgsz warning_text..r)rrctextpairrrorrs )warningsrr;conflictrrrrutilsrZvariadicr r itertoolsr__all__rkr r r rrrobjectrrrrrrrrrs4    '