b_:><ddlZddlmZddlmZ ddlmZn#e$r ddlm ZYnwxYwddl Z ddl Z ddl m Z mZddlmZejd gd Zd Zd Zd Ze jdGddeZdZdZdZdZdZe jddGddeZe jdGddeZe jddGddeZ eZ!dZ"Gd d!eZ#dS)"Nwraps)count)getfullargspec) getargspec) Transitioner Automaton) preserveNameArgSpecargsvarargsvarkwdefaults kwonlyargskwonlydefaults annotationsc t|}tt|j|jt jr|jn|j|j r|j ndt jrt|j ndt jr/|j r&t|j ndndt jr&t|j ndS)z Normalize inspect.ArgSpec across python versions and convert mutable attributes to immutable types. :param Callable func: A function. :return: The function's ArgSpec. :rtype: ArgSpec r ) getArgsSpecr tuplerrsixPY3rkeywordsrrritemsr)funcspecs 3lib/python3.11/site-packages/automat/_methodical.py _getArgSpecr s t  D  49   G6djj"&-7R-0W<5)))"W" +E$%++-- . . .(*7:wFE$*0022333B    czt|j|jz|jrdndz|jrdndz|jzS)a0 Get the name of all arguments defined in a function signature. The name of * and ** arguments is normalized to "*args" and "**kwargs". :param ArgSpec spec: A function to interrogate for a signature. :return: The set of all argument names in `func`s signature. :rtype: Set[str] )z*argsr)z**kwargs)setrrrrr)rs r _getArgNamesr$2sZ  /  -::2 /!J .==B 0      r!c<tfd}|S)a Decorate a function so all its arguments must be passed by keyword. A useful utility for decorators that take arguments so that they don't accidentally get passed the thing they're decorating as their first argument. Only works for methods right now. c|fi|SNr)selfkwfs rgz_keywords_only..gOsq}}}}r!r)r*r+s` r_keywords_onlyr,Es3 1XXX Hr!T)frozenceZdZdZejdZejZejdZe fdZ dZ dS)MethodicalStatez- A state for a L{MethodicalMachine}. Freprc t|j}|D]}t|j}||s^td|jj|jjt|jt|j|j |||||dS)ac Declare a state transition within the :class:`automat.MethodicalMachine` associated with this :class:`automat.MethodicalState`: upon the receipt of the `input`, enter the `state`, emitting each output in `outputs`. :param MethodicalInput input: The input triggering a state transition. :param MethodicalState enter: The resulting state. :param Iterable[MethodicalOutput] outputs: The outputs to be triggered as a result of the declared state transition. :param Callable collector: The function to be used when collecting output return values. :raises TypeError: if any of the `outputs` signatures do not match the `inputs` signature. :raises ValueError: if the state transition from `self` via `input` has already been defined. zdmethod {input} signature {inputSignature} does not match output {output} signature {outputSignature})inputoutputinputSignatureoutputSignatureN) r$argSpecissubset TypeErrorformatmethod__name__rmachine_oneTransition)r(r3enteroutputs collector inputArgsr4 outputArgss ruponzMethodicalState.upon^s&!//   F%fn55J&&y11 228&#l3%}5'25<'@'@(3FM(B(B 3933  ##D%KKKKKr!c|jjSr'r;r<r(s r_namezMethodicalState._name {##r!N) r< __module__ __qualname____doc__attribr=r; serializedlistrDrHrr!rr/r/Usdg5!!!G TWYYFe$$$J48 L L L LD$$$$$r!r/cxt||d}|&t||j}t||||S)z Get a L{Transitioner} N)getattrr initialStatesetattr)oselfsymbol automaton transitioners r_transitionerFromInstancerYsM5&$//L#   "   v|,,, r!cdSr'rrr!r_emptyr[sDr!cdS) docstringNrrr!r _docstringr^sr!c|jjtjjtjjfvrt ddS)Nzfunction body must be empty)__code__co_coder[r^ ValueError)inst attributer*s r assertNoCoderesD z&/"9","5"="???6777??r!c tt|jdd|}jr|}nfd|D}t| |D] \}} ||fz t|jddd|jddd} fd|D} | |jr| } n7jddjz fd| D} || fS)a Filter out arguments that were passed to input that output won't accept. :param tuple args: The *args that input received. :param dict kwargs: The **kwargs that input received. :param ArgSpec inputSpec: The input's arg spec. :param ArgSpec outputSpec: The output's arg spec. :return: The args and kwargs that output will accept. :rtype: Tuple[tuple, dict] rNc,g|]\}}|jv|Sr)r).0nv outputSpecs r z_filterArgs..s)HHHTQ1 3G3Gq3G3G3Gr!c$i|] \}}|v || Srr)rhrirjpassed_arg_namess r z_filterArgs..s*JJJDAq9I0I0I1a0I0I0Ir!c$i|] \}}|v || Srr)rhrirjall_accepted_namess rrpz_filterArgs..s4555$!Q!333A333r!) rziprrrupdaterrr) rkwargs inputSpecrk named_args return_argsnamevaluer full_kwargs return_kwargsrrros ` @@r _filterArgsr}sOs9>!""-t4455JI IHHHZHHH V}}!** eT5M)9>$$B$');DDbD)ABBHJJJJHJJJKv5# (_QRR0:3HH5555+*;*;*=*=555   %%r!F)eqhashc eZdZdZejdZejeZejdZ ejej e dZ ejddZ e jdZd d Zd ZdS) MethodicalInputz. An input for a L{MethodicalMachine}. Fr0) validator)defaultr1initr1c*t|jSr'r r;rGs r _buildArgSpeczMethodicalInput._buildArgSpec4;'''r!Nctjjtjt jfd}|S)z Return a function that takes no arguments and returns values returned by output functions produced by the given L{MethodicalInput} in C{oself}'s current state. c` j g|Ri| j}  \}} j|}g}|D]a}|r||t || j|j\}} | g|Ri| } || b||Sr')r;_state transition collectorsrHr}r7append)rru previousStater@ outTracerrAvaluesr4akrzrUr(rXs rdoInputz(MethodicalInput.__get__..doInputs DK / / / / / / /(/M#/#:#:4#@#@ Wi 6IF! % %.Ifllnn---"4v~NN1u.q...A.. e$$$$9V$$ $r!)rYrVrWr r;r)r(rUtyperrXs`` @r__get__zMethodicalInput.__get__sw 1 15AA dk " " t{   % % % % % %   # " %r!c|jjSr'rFrGs rrHzMethodicalInput._namerIr!r')r<rJrKrLrMrNrWrer;rVFactorydictrr7rrrrHrr!rrrsU###I TW| , , ,F TW% Fd!3!3%@@@Jdg5u---G _((_(2$$$$$r!rceZdZdZejdZejZejddZej dZ d dZ dZ d Z dS) MethodicalOutputz/ An output for a L{MethodicalMachine}. Fr0rc*t|jSr'rrGs rrzMethodicalOutput._buildArgSpecrr!Nchtd|j|jj)zX Outputs are private, so raise an exception when we attempt to get one. zf{cls}.{method} is a state-machine output method; to produce this output, call an input method instead.)clsr;)AttributeErrorr:r<r;r(rUrs rrzMethodicalOutput.__get__ sA DDJFM{+EKEE   r!c$|j|g|Ri|S)z- Call the underlying method. )r;)r(rUrrus r__call__zMethodicalOutput.__call__s&t{5242226222r!c|jjSr'rFrGs rrHzMethodicalOutput._namerIr!r')r<rJrKrLrMrNr=r;r7rrrrrHrr!rrrsdg5!!!G TWYYFdg5u---G _((_(     333 $$$$$r!rcZeZdZejdZejdZddZdS)MethodicalTracerFr0NcHt||j|jfd}|S)Nc2|dSr')setTrace)tracerrXs rrz*MethodicalTracer.__get__..setTrace)s  ! !& ) ) ) ) )r!)rYrVrW)r(rUrrrXs @rrzMethodicalTracer.__get__&s=0 15AA  * * * * *r!r')r<rJrKrMrNrWrVrrr!rrr sPU###I TW% Fr!rcJdtttzS)z, Create a unique Python identifier. _symbol_)strnextcounterrr!rgensymr0s DMM** **r!ceZdZdZdZddZe ddZedZedZ d Z ed Z ed Z e d Zd ZdS)MethodicalMachinezj A :class:`MethodicalMachine` is an interface to an `Automaton` that uses methods on a class. c`t|_i|_t|_dSr')r _automaton _reducersr_symbolrGs r__init__zMethodicalMachine.__init__>s##++xx r!Nc(|td|S)z L{MethodicalMachine} is an implementation detail for setting up class-level state; applications should never need to access it on an instance. Nz.MethodicalMachine is an implementation detail.)rrs rrzMethodicalMachine.__get__Ds'   @BB B r!Fcfd}|S)a Declare a state, possibly an initial state or a terminal state. This is a decorator for methods, but it will modify the method so as not to be callable any more. :param bool initial: is this state the initial state? Only one state on this :class:`automat.MethodicalMachine` may be an initial state; more than one is an error. :param bool terminal: Is this state a terminal state? i.e. a state that the machine can end up in? (This is purely informational at this point.) :param Hashable serialized: a serializable value to be used to represent this state to external systems. This value should be hashable; :py:func:`unicode` is a good type to use. cHt|}r |j_|S)N)r=r;rO)r/rrS) stateMethodstateinitialr(rOs r decoratorz*MethodicalMachine.state..decoratorfs8#D+6/9;;;E 5/4,Lr!r)r(rterminalrOrs`` ` rrzMethodicalMachine.statePs0,       r!cfd}|S)zM Declare an input. This is a decorator for methods. c<tj|jS)N)rWr;rV)rrr) inputMethodr(s rrz*MethodicalMachine.input..decoratorws&"T_*5*.,888 8r!rr(rs` rr3zMethodicalMachine.inputps$ 8 8 8 8 8r!cfd}|S)z Declare an output. This is a decorator for methods. This method will be called when the state machine transitions to this state as specified in the decorated `output` method. c&t|S)N)r=r;)r) outputMethodr(s rrz+MethodicalMachine.output..decorators#DFFF Fr!rrs` rr4zMethodicalMachine.output~s' G G G G Gr!cn|j|||t|||j|<dS)z. See L{MethodicalState.upon}. N)r addTransitionrr)r( startState inputTokenendState outputTokensrAs rr>z MethodicalMachine._oneTransitionsB& %%j*h&+L&9&9 ; ; ;,5 j)))r!cfd}|S) c@tfd}|S)Ncft|jj}||jjSr')rYrrrrO)rUrX decorateer(s r serializezBMethodicalMachine.serializer..decorator..serializes78 9= J J  y (;(FGGGr!r)rrr(s` rrz/MethodicalMachine.serializer..decoratorsC 9   H H H H H  H r!rrs` r serializerzMethodicalMachine.serializers$      r!cfd}|S)rc@tfd}|S)Nc|g|Ri|}i}jD] }|||j< t|jj}|||_dSr')rstatesrOrYrr) rUrrurmapping eachStaterXrr(s r unserializezFMethodicalMachine.unserializer..decorator..unserializes! %9$999&99!%!7!7!9!9>>I4=GI01184< : : &-en #tr!r)rrr(s` rrz1MethodicalMachine.unserializer..decorators= 9          r!rrs` r unserializerzMethodicalMachine.unserializers$     r!c6t|j|jSr')rrrrGs r _setTracezMethodicalMachine._setTraces>>>r!c<ddlm}||jdddS)a Generate a L{graphviz.Digraph} that represents this machine's states and transitions. @return: L{graphviz.Digraph} object; for more information, please see the documentation for U{graphviz} r) makeDigraphc|jjSr'rF)rs rz-MethodicalMachine.asDigraph..  (=r!c|jjSr'rF)r3s rrz-MethodicalMachine.asDigraph..rr!c|jjSr'rF)r4s rrz-MethodicalMachine.asDigraph..s &-*@r!) stateAsString inputAsStringoutputAsString) _visualizerr)r(rs r asDigraphzMethodicalMachine.asDigraphsF ,+++++{ O====@@     r!r')FFN)r<rJrKrLrrr,rr3r4r>rrpropertyrrrr!rrr8s        ,1^>  ^   ^ 6660  ^ ^$??X?     r!r)$ collections functoolsr itertoolsrinspectrr ImportErrorrrMr_corer r _introspectionr namedtupler r r$r,sobjectr/rYr[r^rer}rrrrrrrr!rrs25555555222111111112 ********(((((( !+ -N-N-N O O 0&    t+$+$+$+$+$f+$+$+$\      888"%&%&%&P5u($($($($($f($($($Vt $ $ $ $ $v $ $ $D5u     v    %''+++b b b b b b b b b b s  ''