a %gh4@sddlmZddlZddlmZmZmZmZddlm Z ddl m Z m Z ddl ZGdddeZd d Zd d Zefd dZddZddZGdddeZddZGdddeZddZddZdS))warnN)ordering ambiguitiessuper_signatureAmbiguityWarning) expand_tuples)Variadic isvariadicc@seZdZdZdS)MDNotImplementedErrorz+A NotImplementedError for multiple dispatchN)__name__ __module__ __qualname____doc__rrk/mounts/lovelace/software/anaconda3/envs/metaDMG/lib/python3.9/site-packages/multipledispatch/dispatcher.pyr sr cCstt|j|tdS)aBRaise 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_warn srcCstdtdS)z5Deprecated interface to temporarily disable ordering.z=halt_ordering is deprecated, you can safely remove this call.NrDeprecationWarningrrrr halt_orderingsrcCstdtdS)z4Deprecated 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_ambiguityrrrrestart_ordering&srccsvt|}t|}|D]$}t||}|Vt|st|}qz t|}Wn$tyjt|s`JdVYn0dVdS)ajCheck 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_signatureZsigitersigtypmatchesrrrvariadic_signature_matches_iter0s      r$cCs|sJtt||SN)allr$)rr rrrvariadic_signature_matchesZsr'c@seZdZdZdZd*ddZddZedd Zed d Z d d Z e ddZ e fddZddZddZeZddZddZddZddZddZe d d!Zd"d#Zd$d%Zd&d'Zd(d)ZdS)+ DispatcheraVDispatch methods based on type signature Use ``dispatch`` to add implementations Examples -------- >>> 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 )r rfuncs _ordering_cachedocNcCs"||_|_i|_||_i|_dSr%)rr r)r,r+)selfrr,rrr__init__ys zDispatcher.__init__csfdd}|S)aregister 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|fi|Sr%)add)funckwargsr-rrr_dfsz Dispatcher.register.._dfr)r-rr2r3rr1rregisterszDispatcher.registercCs"ttdrt|}|jSdS)N signature)hasattrinspectr5 parametersvaluesclsr0r!rrrget_func_paramss  zDispatcher.get_func_paramscsV||}|rRtjfdd|D}tdd|D}tfdd|DrR|SdS)z1get annotations of function positional parametersc3s$|]}|jjjfvr|VqdSr%)kindPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORD.0param Parameterrr s  z2Dispatcher.get_func_annotations..css|] }|jVqdSr%) annotationr@rrrrEc3s|]}|juVqdSr%)empty)rAannrCrrrErGN)r<r7rDtupler&)r;r0params annotationsrrCrget_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|`WntyYn0dS) aKAdd 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%) isinstancerJ)rAr"rrrrErGz!Dispatcher.add..Nr)start, css&|]}t|tr|jnt|VqdSr%)rNtyper str)rAcrrrrEszDTried 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)rManyrr/ enumeraterNrQlistjoin TypeErrorrlenappendr r)rJr+clearr*AttributeError) r-r5r0rLZtypsZ new_signatureindexr"Zstr_sigrrrr/sD         zDispatcher.addcCs(z|jWSty"|YS0dSr%)r*r\reorderr-rrrrs zDispatcher.orderingcCs,t|j|_}t|j}|r(||||Sr%)rr)r*r)r-rZodambrrrr^s   zDispatcher.reorderc Ostdd|D}z|j|}Wn@ty`|j|}|sRtd|jt|f||j|<Yn0z||i|WSty|j|}t ||D]0}z||i|WYStyYq0qtd|jt|fYn0dS)NcSsg|] }t|qSrrQrAargrrr rGz'Dispatcher.__call__..%Could not find signature for %s: <%s>zFMatching functions for %s: <%s> found, but none completed successfully) rJr+KeyErrordispatchNotImplementedErrorr str_signaturer dispatch_iterr)r-argsr2rr0r)rrr__call__ s:      zDispatcher.__call__cCs d|jS)Nzrr_rrr__str__+szDispatcher.__str__cGs>||jvr|j|Szt|j|WSty8YdS0dS)aQDeterimine 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 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)rrjrr-rrrrrg0s    zDispatcher.dispatchcgstt|}|jD]`}t||kr@ttt||r@|j|}|Vqt|rt|drt||r|j|}|VqdS)N)rYrr&maprr)r r')r-rnr5resultrrrrjNs    zDispatcher.dispatch_itercCstdt|j|S)zDeterimine appropriate implementation for this type signature .. deprecated:: 0.4.4 Use ``dispatch(*types)`` instead z-resolve() is deprecated, use dispatch(*types))rrrgrorrrresolveYs zDispatcher.resolvecCs|j|jdS)Nrr)rur_rrr __getstate__cszDispatcher.__getstate__cCs,|d|_|d|_t|j|_t|_dS)Nrr))rr)rr*dictr+)r-drrr __setstate__fs   zDispatcher.__setstate__cCsd|jg}|jr||jg}|jdddD]\}|j|}|jrdt|}|dt|d7}||j7}||q2|t|q2|r|dd |d |S) NzMultiply dispatched method: %srpz Inputs: <%s> - zOther signatures: z  ) rr,rZrr)rrirYstriprW)r-docsotherr!r0srrrrls     zDispatcher.__doc__cGs|jtt|jSr%)rgrqrQr)r-rkrrr_helpszDispatcher._helpcOst|j|dS)z8Print docstring for the function corresponding to inputsN)printrr-rkr2rrrhelpszDispatcher.helpcGs$|jtt|}|stdt|S)NzNo function found)rgrqrQrXsource)r-rkr0rrr_sourceszDispatcher._sourcecOst|j|dS)z:Print source code for the function corresponding to inputsN)rrrrrrrszDispatcher.source)N)r r rr __slots__r.r4 classmethodr<rMr/propertyrrr^rlrn__repr__rgrjrtrvryrrrrrrrrr(`s4 !  B  !   r(cCs dt|}|t|}|S)Nz File: %s )r7 getsourcefile getsource)r0rrrrrsrc@s0eZdZdZdZeddZddZddZd S) MethodDispatcherzODispatch methods based on type signature See Also: Dispatcher objr;cCs,ttdr(t|}t|jddSdS)Nr5r)r6r7r5itlislicer8r9r:rrrr<s  z MethodDispatcher.get_func_paramscCs||_||_|Sr%r)r-instanceownerrrr__get__szMethodDispatcher.__get__cOsNtdd|D}|j|}|s6td|jt|f||jg|Ri|S)NcSsg|] }t|qSrrarbrrrrdrGz-MethodDispatcher.__call__..re)rJrgrhrrir)r-rkr2rr0rrrrls  zMethodDispatcher.__call__N) r r rrrrr<rrlrrrrrs  rcCsddd|DS)zbString representation of type signature >>> str_signature((int, float)) 'int, float' rPcss|] }|jVqdSr%)r )rAr;rrrrErGz str_signature..rW)r!rrrrisricsbd}|d7}|D]$}|dddd|Dd7}q|d7}|d fd d |D7}|S) zThe text for ambiguity warningsz. Ambiguities exist in dispatched function %s z;The following signatures may result in ambiguous behavior:  rPcss|]}dt|dVqdS)[]N)rirArrrrrErGzwarning_text..r{z, Consider making the following additions: r|cs$g|]}dtt|dqS)z @dispatch(z ) def %s(...))rirrrmrrrdsz warning_text..r)rr`textpairrrmrrs" r)warningsrr7conflictrrrrutilsrZvariadicr r itertoolsrrhr rrrr$r'objectr(rrrirrrrrs$   *7