If[ClUddlmZddlZddlZddlmZmZddlmZddl m Z ddl m Z ddlmZmZmZmZmZej(dkrdd lmZndd lmZd d lmZmZmZmZd d lmZej<d gdZdZ dZ!dZ"edGdde#Z$ d,dZ%dZ&dZ'd-dZ(dZ)edZ*edZ+edGdd e#Z,edGd!d"e#Z-ee.gdfZ/d#Z0d$e1d%< d.d&Z2edGd'd(e#Z3e Z4d)Z5Gd*d+e#Z6y)/) annotationsN) dataclassfieldwraps)getfullargspec)count)AnyCallableHashableIterableTypeVar) ) TypeAlias) Automaton OutputTracerTracer Transitioner) preserveNameArgSpecargsvarargsvarkwdefaults kwonlyargskwonlydefaultsrc t|}tt|j|j|j |j r |j ndt|j|jr#t|jjndt|jjS)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) getArgsSpecrtuplerrrrrritemsr)funcspecs N/var/www/cs2snipe.com/venv/lib/python3.12/site-packages/automat/_methodical.py _getArgSpecr("s t D  499  jj"&--R)262E2EE$%%++- .2$**0023  ct|j|jz|jrdndz|jrdndz|j zS)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)r&s r' _getArgNamesr,9sV  // :2 /!JJ=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 r'gz_keywords_only..gWs}}r)r)r2r3s` r'_keywords_onlyr4Ls" 1X Hr)T)frozenceZdZUdZedZded<eZded<edZded <d d e f d d Z dd Z y )MethodicalStatez- A state for a L{MethodicalMachine}. FreprMethodicalMachinemachineCallable[..., Any]methodbool serializedNc ||}|g}t|j}|D]}t|j}|j|r*tdj |j j |j j t|j t|j |jj|||||y)a Declare a state transition within the L{MethodicalMachine} associated with this L{MethodicalState}: upon the receipt of the `input`, enter the `state`, emitting each output in `outputs`. @param input: The input triggering a state transition. @param enter: The resulting state. @param outputs: The outputs to be triggered as a result of the declared state transition. @param 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. Nzdmethod {input} signature {inputSignature} does not match output {output} signature {outputSignature})inputoutputinputSignatureoutputSignature) r,argSpecissubset TypeErrorformatr=__name__r"r;_oneTransition)r0rAenteroutputs collector inputArgsrB outputArgss r'uponzMethodicalState.uponhs8 =E ?G /  F%fnn5J&&y1228&#ll33%}}55'25<<'@(3FMM(B 393    ##D%Kr)c.|jjSr/r=rIr0s r'_namezMethodicalState._name{{###r)) rAMethodicalInputrKzMethodicalState | NonerLz!Iterable[MethodicalOutput] | NonerMzCallable[[Iterable[T]], object]returnNonerWstr) rI __module__ __qualname____doc__rr;__annotations__r=r?listrPrTr!r)r'r7r7^s"'E!2G 2!&F (%(J( )-5959 .L.L&.L3 .L 3 .L  .L`$r)r7cjt||d}|#t||j}t||||S)z Get a L{Transitioner} N)getattrr initialStatesetattr)oselfsymbol automaton transitioners r'_transitionerFromInstancerhsB5&$/L#   " "  v|, r)cyr/r!r!r)r'_emptyrjsr)cy) docstringNr!r!r)r' _docstringrmsr)c|jjtjjtjjfvr t dy)Nzfunction body must be empty)__code__co_coderjrm ValueError)r2s r' assertNoCoderrsC zz&//"9"9:;N;N;V;V!WW677Xr)chtt|jdd|}|jr|}n#|Dcgc]\}}||jvs|}}}t|}|D] \} } || | fz }t|jddd|jddd} | Dcic] \}}||vs ||} }}| j ||j r| } || fS|jdd|jz}| jDcic] \}}||vs ||} }}|| fScc}}wcc}}wcc}}w)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] rN) r#ziprrrupdaterrr$)rkwargs inputSpec outputSpec named_args return_argsnvpassed_arg_namesnamevaluer full_kwargs return_kwargsall_accepted_namess r' _filterArgsrscs9>>!"-t45J &0HTQ1 3GqH HV}!* eT5M)*9>>$B$'););DbD)ABH$,JDAq9I0I1a4JKJv#   %% (__QR0:3H3HH(..0 QA9K4KAqD    %%)IK s#D"D"" D(/D( D.D.TRF)eqceZdZUdZedZded<eZded<edZded <ee d Z d ed <edd Z ded<ddZ dddZ ddZy)rVz. An input for a L{MethodicalMachine}. Fr8=Automaton[MethodicalState, MethodicalInput, MethodicalOutput]rfr<r=rZre)default_factoryr9z1dict[MethodicalState, Callable[[Iterable[T]], R]] collectors)initr9rrEcbt|j|_t|jyr/)r(r=rErrrSs r' __post_init__zMethodicalInput.__post_init__s"4;;/ T[[!r)Nctjjtjt jdfd }|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. cH j g|i| j} j \}} j|}g}|D]N}|||t || j |j \}} | g|i| } |j | P||Sr/)r=_state transitionrrrEappend)rrw previousStaterL outTracerrMvaluesrBakrrdr0rgs r'doInputz(MethodicalInput.__get__..doInputs DKK / / /(//M#/#:#:4#@ Wi 6IF! %(f%"4v~~N1u.q.A. e$  % V$ $r))robjectrwrrWr)rhrerfrr=r)r0rdtyperrgs`` @r'__get__zMethodicalInput.__get__sN 1 T^^T dkk " t{{  %  # %r)c.|jjSr/rRrSs r'rTzMethodicalInput._name"rUr)rWrXr/)rdrrrXrWrrY)rIr[r\r]rrfr^r=redictrrErrrTr!r)r'rVrVsyPU PIL"'F (U#FC#DI5EJA%e4GW4"4$r)rVcveZdZUdZedZded<ded<edddZd ed <dd Zdd Z dZ ddZ y )MethodicalOutputz/ An output for a L{MethodicalMachine}. Fr8r:r;r<r=)rr9comparerrEcHt|j|jd<y)NrE)r(r=__dict__rSs r'rzMethodicalOutput.__post_init__0s#.t{{#; i r)Ncvtdj|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=)AttributeErrorrHrIr=r0rdrs r'rzMethodicalOutput.__get__3s< DDJFMM$++*>*>EKE  r)c.|j|g|i|S)z- Call the underlying method. )r=)r0rdrrws r'__call__zMethodicalOutput.__call__>st{{5242622r)c.|jjSr/rRrSs r'rTzMethodicalOutput._nameDrUr)rr/rY) rIr[r\r]rr;r^rErrrrTr!r)r'rr&sF"'E!2G 2 %eUCGWC<  3 $r)rz4Callable[[str, str, str], StringOutputTracer | None]r StringTracerc*y dfd }|S)Nc~|j|j|jfdSy)Nc0|jSr/rT)outresults r'z,wrapTracer..tracer..Ysvciik2r)r)staterArBrwrappeds @r'tracerzwrapTracer..tracerRs4  v||~F  2 2r))rr7rArVrBr7rWz%OutputTracer[MethodicalOutput] | Noner!)rrs` r' wrapTracerrLs=  /  Mr)c\eZdZUedZded<edZded< d d dZy) MethodicalTracerFr8rrfrZreNcVt||j|jdfd }|S)Nc:jt|yr/)setTracer)rrgs r'rz*MethodicalTracer.__get__..setTraceks  ! !*V"4 5r))rStringTracer | NonerWrX)rhrerf)r0rdrrrgs @r'rzMethodicalTracer.__get__fs'1 T^^T  6r)r/)rdrrrrWzCallable[[StringTracer], None])rIr[r\rrfr^rerr!r)r'rr_sKOT PILU#FC#-1#) 'r)rc8dtttzS)z, Create a unique Python identifier. _symbol_)rZnextcounterr!r)r'gensymrts DM* **r)ceZdZdZdZd dZe d ddZedZedZ dZ ed Z ed Z e dd Zd Zy)r:ze A L{MethodicalMachine} is an interface to an L{Automaton} that uses methods on a class. cNt|_i|_t|_yr/)r _automaton _reducersr_symbolrSs r'__init__zMethodicalMachine.__init__s#+x 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. z.MethodicalMachine is an implementation detail.)rrs r'rzMethodicalMachine.__get__s   !QR R r)cfd}|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 initial: is this state the initial state? Only one state on this L{automat.MethodicalMachine} may be an initial state; more than one is an error. @param 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 serialized: a serializable value to be used to represent this state to external systems. This value should be hashable; L{str} is a good type to use. cJt|}r|j_|S)N)r;r=r?)r7rrb) stateMethodrinitialr0r?s r' decoratorz*MethodicalMachine.state..decorators*#[ZE/4,Lr)r!)r0rterminalr?rs`` ` r'rzMethodicalMachine.states. r)cfd}|S)zM Declare an input. This is a decorator for methods. cHtj|jS)N)rfr=re)rVrr) inputMethodr0s r'rz*MethodicalMachine.input..decorators"//+dll r)r!r0rs` r'rAzMethodicalMachine.inputs  r)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. ct|S)N)r;r=)r) outputMethodr0s r'rz+MethodicalMachine.output..decorators#DF Fr)r!rs` r'rBzMethodicalMachine.outputs Gr)cp|jj|||t|||j|<y)z. See L{MethodicalState.upon}. N)r addTransitionr#r)r0 startState inputTokenendState outputTokensrMs r'rJz MethodicalMachine._oneTransitions6$ %%  HeL.A -6 j)r)cfd}|S) c2tfd}|S)Nct|jj}||jjSr/)rhrrrr?)rdrg decorateer0s r' serializezBMethodicalMachine.serializer..decorator..serializes784<<  ! (;(;(F(FGGr)r)rrr0s` r'rz/MethodicalMachine.serializer..decorators$ 9  H H  r)r!rs` r' serializerzMethodicalMachine.serializers r)cfd}|S)rc2tfd}|S)Nc|g|i|}i}jjD]}|||j<t|jj}|||_yr/)rstatesr?rhrr) rdrrwrmapping eachStatergrr0s r' unserializezFMethodicalMachine.unserializer..decorator..unserializesr!%9$9&9!%!7!7!9>I4=GI001>84<<  '.en #r)r)rrr0s` r'rz1MethodicalMachine.unserializer..decorators" 9    r)r!rs` r' unserializerzMethodicalMachine.unserializers r)cBt|j|jSr/)rrrrSs r' _setTracezMethodicalMachine._setTrace s>>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/rR)rs r'rz-MethodicalMachine.asDigraph.. (=(=r)c.|jjSr/rR)rAs r'rz-MethodicalMachine.asDigraph..rr)c.|jjSr/rR)rBs r'rz-MethodicalMachine.asDigraph.. s&--*@*@r)) stateAsString inputAsStringoutputAsString) _visualizerr)r0rs r' asDigraphzMethodicalMachine.asDigraphs$ , OO==@   r)r/)FFN)rr>rr>r?r )rWr)rIr[r\r]rrr4rrArBrJrrpropertyrrr!r)r'r:r:{s  TX/3IQ@    6.  (?? r)r:)rdrrerZrfrrWz@Transitioner[MethodicalState, MethodicalInput, MethodicalOutput])r2r<rWrX)rrrWzATracer[MethodicalState, MethodicalInput, MethodicalOutput] | None)7 __future__r collectionssys dataclassesrr functoolsrinspectrr" itertoolsr typingr r r r r version_infotyping_extensionsr_corerrrr_introspectionr namedtuplerr(r,r4rr7rhrjrmrrrrrrVrrZStringOutputTracerrr^rrrrr:r!r)r'rs" (1==g+ @@( +   .& $ $:$f:$:$z  MF $  8 &&R CL CL e/$f/$/$d $$v$$BseTk*P iP F& ev" '+f f r)