U Zʹj/@sUddlmZddlmZddlZddlmZmZmZm Z ddl m Z ddl Z GdddeZd d ZGd d d Zd dZeZded<dgZddZefddZGdddZddZGdddeZddZddZdS) ) annotations)warnN)ordering ambiguitiessuper_signatureAmbiguityWarning) expand_tuplesc@seZdZdZdS)MDNotImplementedErrorz- A NotImplementedError for multiple dispatch N)__name__ __module__ __qualname____doc__rr`/var/www/html/bwave/python/venv/lib/python3.8/site-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__$sz!RaiseNotImplementedError.__init__cOs.tdd|D}td|jjt|fdS)Ncss|]}t|VqdSrtype).0arrr (sz4RaiseNotImplementedError.__call__..z Ambiguous signature for %s: <%s>)tupleNotImplementedErrorrr str_signature)rargskwargstypesrrr__call__'sz!RaiseNotImplementedError.__call__N)r r r rrr$rrrrr!srcCs@|D]6}tt|}tt|dkr&q|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*zset[Dispatcher]_unresolved_dispatchersTcCs dtd<dS)NFr)_resolverrrr halt_orderingNsr/cCs&dtd<tr"t}|j|dqdS)NTrr%)r.r-popreorder)r&rrrrrestart_orderingRsr2c@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(||_|_i|_i|_g|_||_dSr)rr r4r5rr6)rrr6rrrrqs  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|f|Sr)r))funcr"rr#rr_szDispatcher.register.._r)rr#r"r9rr8rregisterxszDispatcher.registercCs"ttdrt|}|jSdS)Nr,)hasattrinspectr, parametersvaluesclsr7sigrrrget_func_paramss  zDispatcher.get_func_paramscsV||}|rRtjfdd|D}tdd|D}tfdd|DsR|SdS)z; Get annotations of function positional parameters c3s$|]}|jjjfkr|VqdSr)kindPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORDrparam Parameterrrrsz2Dispatcher.get_func_annotations..css|] }|jVqdSr) annotationrFrrrrsc3s|]}|jkVqdSr)empty)rannrHrrrsN)rBr<rIrany)r@r7paramsrrrHrget_func_annotationss zDispatcher.get_func_annotationscCs|s||}|r|}tdd|DrHt|D]}||||q0dS|D]6}t|tsLddd|D}td|||jfqL||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)rtyprrrrsz!Dispatcher.add..N, css&|]}t|tr|jnt|VqdSr)rPrr str)rcrrrrszDTried to dispatch on non-type: %s In signature: <%s> In function: %sr%) rOrMr r)rPrjoin TypeErrorrr4r1r5clear)rr,r7r&rZtypsrQZstr_sigrrrr)s&       zDispatcher.addcCs<tdr.t|j|_t|j}|r8|||n t|dS)Nr)r.rr4rr-r))rr&r+rrrr1s    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|qSrrrargrrr sz'Dispatcher.__call__..%Could not find signature for %s: <%s>zFMatching functions for %s: <%s> found, but none completed successfully) rr5KeyErrordispatchrrr r dispatch_iternext)rr!r"r#r7r4rrrr$s2     zDispatcher.__call__cCs d|jS)Nzrrrrr__str__szDispatcher.__str__cGs@||jkr|j|Szt|j|WStk r:YdSXdS)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)r4r_r^ StopIterationrr#rrrr]s   zDispatcher.dispatchcgsDt|}|jD]0}t||krttt||r|j|}|VqdSr)r'rallmap issubclassr4)rr#nr,resultrrrr^#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))rDeprecationWarningr]rdrrrresolve*szDispatcher.resolvecCs|j|jdS)Nrr4rlrarrr __getstate__5szDispatcher.__getstate__cCs*|d|_|d|_t|j|_i|_dS)Nrr4)rr4rr5)rdrrr __setstate__9s   zDispatcher.__setstate__cCsd|jg}|jr||jg}|jdddD]\}|j|}|jrdt|}|dt|d7}||j7}||q2|t|q2|r|dd |d |S) NzMultiply dispatched method: %sz Inputs: <%s> - zOther signatures: z  ) rr6appendrr4rr r'striprU)rdocsotherrAr7srrrr?s     zDispatcher.__doc__cGs|jtt|jSr)r]rfrr)rr!rrr_helpVszDispatcher._helpcOst|j|dS)z: Print docstring for the function corresponding to inputs N)printryrr!r"rrrhelpYszDispatcher.helpcGs$|jtt|}|stdt|S)NzNo function found)r]rfrrVsource)rr!r7rrr_source]szDispatcher._sourcecOst|j|dS)z< Print source code for the function corresponding to inputs N)rzr~r{rrrr}cszDispatcher.source)N)r r r r __slots__rr: classmethodrBrOrr)r1r$rb__repr__r]r^rkrmropropertyryr|r~r}rrrrr3Ys0     ,   r3cCs dt|}|t|}|S)Nz File: %s )r< getsourcefile getsource)r7rxrrrr}hsr}c@s,eZdZdZeddZddZddZdS) MethodDispatcherzP Dispatch methods based on type signature See Also: Dispatcher cCs,ttdr(t|}t|jddSdS)Nr,r)r;r<r,itlislicer=r>r?rrrrBus  z MethodDispatcher.get_func_paramscCs||_||_|Sr)objr@)rinstanceownerrrr__get__{szMethodDispatcher.__get__cOsHtdd|D}|j|}|s6td|jt|f||jf||S)NcSsg|] }t|qSrrrXrrrrZsz-MethodDispatcher.__call__..r[)rr]rrr r)rr!r"r#r7rrrr$s  zMethodDispatcher.__call__N)r r r rrrBrr$rrrrrns  rcCsddd|DS)z String representation of type signature >>> from sympy.multipledispatch.dispatcher import str_signature >>> str_signature((int, float)) 'int, float' rRcss|] }|jVqdSr)r )rr@rrrrsz str_signature..rU)rArrrr 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:  rRcss|]}dt|dVqdS)[]N)r rrxrrrrszwarning_text..rrz, Consider making the following additions: rscs$g|]}dtt|dqS)z @dispatch(z ) def %s(...))r rrr`rrrZsz warning_text..r)rr+textpairrr`rrs r) __future__rwarningsrr<conflictrrrrutilsr itertoolsrrr rrr*r(r-__annotations__r.r/r2r3r}rr rrrrrs*