o 8Va/@sddlmZddlmZddlZddlmZmZmZm Z ddl m Z ddl Z GdddeZd d ZGd d d Zd dZeZdgZddZefddZGdddZddZGdddeZddZddZdS))Set)warnN)ordering ambiguitiessuper_signatureAmbiguityWarning) expand_tuplesc@seZdZdZdS)MDNotImplementedErrorz- A NotImplementedError for multiple dispatch N)__name__ __module__ __qualname____doc__rrC/usr/lib/python3/dist-packages/sympy/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) dispatcherrrrrambiguity_warnsrc@s eZdZdZddZddZdS)RaiseNotImplementedErrorz*Raise ``NotImplementedError`` when called.cCs ||_dSN)r)selfrrrr__init__$ z!RaiseNotImplementedError.__init__cOs*tdd|D}td|jjt|f)Ncss|]}t|VqdSrtype).0arrr (sz4RaiseNotImplementedError.__call__..z Ambiguous signature for %s: <%s>)tupleNotImplementedErrorrr str_signature)rargskwargstypesrrr__call__'s  z!RaiseNotImplementedError.__call__N)r r r rrr%rrrrr!s rcCs@|D]}tt|}tt|dkrq|j|t|tdqdS)a If super signature for ambiguous types is duplicate types, ignore it. Else, register instance of ``RaiseNotImplementedError`` for ambiguous types. 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 ambiguity_warn r on_ambiguityN)rrlensetaddr#ambiguity_register_error_ignore_dup)rramb signaturerrrr+.s r+TcCs dtd<dS)NFr)_resolverrrr halt_orderingNs r/cCs,dtd<trt}|j|dtsdSdS)NTrr&)r._unresolved_dispatcherspopreorder)r'rrrrrestart_orderingRs   r3c@seZdZdZdZd(ddZddZedd Zed d Z e fd d Z e fddZ ddZ ddZeZddZddZddZddZddZeddZd d!Zd"d#Zd$d%Zd&d'ZdS)) Dispatcheraj Dispatch methods based on type signature Use ``dispatch`` to add implementations Examples -------- >>> from sympy.multipledispatch import dispatch >>> @dispatch(int) ... def f(x): ... return x + 1 >>> @dispatch(float) ... def f(x): # noqa: F811 ... return x - 1 >>> f(3) 4 >>> f(3.0) 2.0 )r rfuncsr_cachedocNcCs,||_|_t|_t|_g|_||_dSr)rr dictr5r6rr7)rrr7rrrrqs  zDispatcher.__init__csfdd}|S)a# Register dispatcher with new implementation >>> from sympy.multipledispatch.dispatcher import Dispatcher >>> 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)r*)funcr#rr$rr_szDispatcher.register.._r)rr$r#r;rr:rregisterxszDispatcher.registercCs"ttdrt|}|jSdS)Nr-)hasattrinspectr- parametersvaluesclsr9sigrrrget_func_paramss   zDispatcher.get_func_paramscsZ||}|r)tjfdd|D}tdd|D}tfdd|Dr+|SdSdS)z; Get annotations of function positional parameters c3s&|]}|jjjfvr|VqdSr)kindZPOSITIONAL_ONLYZPOSITIONAL_OR_KEYWORDrZparam Parameterrrrsz2Dispatcher.get_func_annotations..cs|]}|jVqdSr) annotationrFrrrrs  c3s|]}|juVqdSr)empty)rannrGrrrN)rDr>rHrall)rBr9params annotationsrrGrget_func_annotationss  zDispatcher.get_func_annotationscCs|s ||}|r |}tdd|Dr$t|D] }||||qdS|D]}t|tsAddd|D}td|||jfq&||j |<|j |d|j dS)a Add new types/method pair to dispatcher >>> from sympy.multipledispatch import 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) isinstancer)rtyprrrrrMz!Dispatcher.add..N, css(|]}t|tr |jnt|VqdSr)rRrr str)rcrrrrs  zDTried to dispatch on non-type: %s In signature: <%s> In function: %sr&) rQanyr r*rRrjoin TypeErrorrr5r2r6clear)rr-r9r'rPZtypsrSZstr_sigrrrr*s(       zDispatcher.addcCsBtdrt|j|_t|j}|r|||dSdSt|dS)Nr)r.rr5rr0r*)rr'r,rrrr2s  zDispatcher.reorderc Ostdd|D}z|j|}Wn ty0|j|}|s)td|jt|f||j|<Ynwz||i|WStyn|j|}t ||D]}z ||i|WYStybYqKwtd|jt|fw)NcSg|]}t|qSrrrargrrr z'Dispatcher.__call__..%Could not find signature for %s: <%s>zFMatching functions for %s: <%s> found, but none completed successfully) rr6KeyErrordispatchr rr!r dispatch_iternext)rr"r#r$r9r5rrrr%s8       zDispatcher.__call__cCs d|jS)Nzrrrrr__str__rzDispatcher.__str__cGs:||jvr |j|Szt|j|WStyYdSw)a` Deterimine 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 sympy.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: ``sympy.multipledispatch.conflict`` - module to determine resolution order N)r5rdrc StopIterationrr$rrrrbs   zDispatcher.dispatchcgsFt|}|jD]}t||kr ttt||r |j|}|VqdSr)r(rrNmap issubclassr5)rr$nr-resultrrrrc#s  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))rDeprecationWarningrbrirrrresolve*s zDispatcher.resolvecCs|j|jdS)Nrr5rprfrrr __getstate__5szDispatcher.__getstate__cCs,|d|_|d|_t|j|_t|_dS)Nrr5)rr5rr8r6)rdrrr __setstate__9s    zDispatcher.__setstate__cCsd|jg}|jr||jg}|jdddD].}|j|}|jr@dt|}|dt|d7}||j7}||q|t|q|rT|dd |d |S) NzMultiply dispatched method: %sz Inputs: <%s> - zOther signatures: z  ) rr7appendrr5rr!r(striprX)rZdocsotherrCr9srrrr?s      zDispatcher.__doc__cGs|jtt|jSr)rbrjrr)rr"rrr_helpVszDispatcher._helpcOt|j|dS)z: Print docstring for the function corresponding to inputs N)printr|rr"r#rrrhelpYzDispatcher.helpcGs$|jtt|}|stdt|S)NzNo function found)rbrjrrYsource)rr"r9rrr_source]szDispatcher._sourcecOr})z< Print source code for the function corresponding to inputs N)r~rrrrrrcrzDispatcher.sourcer)r r r r __slots__rr< classmethodrDrQrr*r2r%rg__repr__rbrcrorqrspropertyr|rrrrrrrr4Ys2     ,    r4cCs dt|}|t|}|S)Nz File: %s )r>Z getsourcefileZ getsource)r9r{rrrrhsrc@s,eZdZdZeddZddZddZdS) MethodDispatcherzP Dispatch methods based on type signature See Also: Dispatcher cCs,ttdrt|}t|jddSdS)Nr-r)r=r>r-itlislicer?r@rArrrrDus  z MethodDispatcher.get_func_paramscCs||_||_|Sr)objrB)rinstanceownerrrr__get__{szMethodDispatcher.__get__cOsNtdd|D}|j|}|std|jt|f||jg|Ri|S)NcSr[rrr\rrrr^r_z-MethodDispatcher.__call__..r`)rrbr rr!r)rr"r#r$r9rrrr%s  zMethodDispatcher.__call__N)r r r rrrDrr%rrrrrns   rcCsddd|DS)z String representation of type signature >>> from sympy.multipledispatch.dispatcher import str_signature >>> str_signature((int, float)) 'int, float' rTcsrIr)r )rrBrrrrsz str_signature..rX)rCrrrr!sr!csbd}|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:  rTcss |] }dt|dVqdS)[]N)r!rr{rrrrszwarning_text..rvz, Consider making the following additions: rwcs$g|]}dtt|dqS)z @dispatch(z ) def %s(...))r!rrrerrr^s z warning_text..r)rr,textZpairrrerrs r)typingrwarningsrr>ZconflictrrrrZutilsr itertoolsrr r rrr+r)r0r.r/r3r4rrr!rrrrrs*