Vh;DlUddlmZddlZddlZddlmZmZddlmZddl 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 C/home/dcms/DCMS/lib/python3.12/site-packages/automat/_methodical.py _getArgSpecr("s t D  499  jj"&--R)262E2EE$%%++- .2$**0023  ct|j|jz|jrdndz|jrdndzt d|j DzS)a Get the name of all arguments defined in a function signature. The name of * and ** arguments is normalized to "*args" and "**kwargs". Return type annotations are omitted, since we don't constrain input methods to have the same return type as output methods, nor output methods to have the same output type. :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**kwargsc32K|]}|ddk7s |yw)rreturnNr!).0as r' z_getArgNames..Ls@aqtx/?@s )setrrrrr#r)r&s r' _getArgNamesr19sb  // :2 /!JJ=B 0 @4++@ @  A 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..g[s}}r)r)r7r8s` r'_keywords_onlyr9Ps" 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) r1argSpecissubset TypeErrorformatrB__name__r"r@_oneTransition)r5rFenteroutputs collector inputArgsrG outputArgss r'uponzMethodicalState.uponls8 =E ?G /  F%fnn5J&&y1228&#ll33%}}55'25<<'@(3FMM(B 393    ##D%Kr)c.|jjSr4rBrNr5s r'_namezMethodicalState._name{{###r)) rFMethodicalInputrPzMethodicalState | NonerQz!Iterable[MethodicalOutput] | NonerRzCallable[[Iterable[T]], object]r,Noner,str) rN __module__ __qualname____doc__rr@__annotations__rBrDlistrUrYr!r)r'r<r<bs"'E!2G 2!&F (%(J( )-5959 .L.L&.L3 .L 3 .L  .L`$r)r<cjt||d}|#t||j}t||||S)z Get a L{Transitioner} N)getattrr initialStatesetattr)oselfsymbol automaton transitioners r'_transitionerFromInstancerlsB5&$/L#   " "  v|, r)cyr4r!r!r)r'_emptyrnsr)cy) docstringNr!r!r)r' _docstringrqsr)c|jjtjjtjjfvr t dy)Nzfunction body must be empty)__code__co_codernrq ValueError)r7s r' assertNoCodervsC 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)r[z. An input for a L{MethodicalMachine}. Fr==Automaton[MethodicalState, MethodicalInput, MethodicalOutput]rjrArBr^ri)default_factoryr>z1dict[MethodicalState, Callable[[Iterable[T]], R]] collectors)initr>rrJcbt|j|_t|jyr4)r(rBrJrvrXs 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||Sr4)rB_state transitionrrrJappend)rr{ previousStaterQ outTracerrRvaluesrGr.krrhr5rks r'doInputz(MethodicalInput.__get__..doInputs DKK / / /(//M#/#:#:4#@ Wi 6IF! %(f%"4v~~N1u.q.A. e$  % V$ $r))robjectr{rr,r)rlrirjrrBr)r5rhtyperrks`` @r'__get__zMethodicalInput.__get__ sN 1 T^^T dkk " t{{  %  # %r)c.|jjSr4rWrXs r'rYzMethodicalInput._name&rZr)r,r\r4)rhrrr\r,rr])rNr_r`rarrjrbrBridictrrJrrrYr!r)r'r[r[syPU PIL"'F (U#FC#DI5EJA%e4GW4"4$r)r[cveZdZUdZedZded<ded<edddZd ed <dd Zdd Z dZ ddZ y )MethodicalOutputz/ An output for a L{MethodicalMachine}. Fr=r?r@rArB)rr>comparerrJcHt|j|jd<y)NrJ)r(rB__dict__rXs r'rzMethodicalOutput.__post_init__4s#.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.)clsrB)AttributeErrorrMrNrBr5rhrs r'rzMethodicalOutput.__get__7s< DDJFMM$++*>*>EKE  r)c.|j|g|i|S)z- Call the underlying method. )rB)r5rhrr{s r'__call__zMethodicalOutput.__call__Bst{{5242622r)c.|jjSr4rWrXs r'rYzMethodicalOutput._nameHrZr)rr4r]) rNr_r`rarr@rbrJrrrrYr!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|jSr4rY)outresults r'z,wrapTracer..tracer..]svciik2r)r)staterFrGrwrappeds @r'tracerzwrapTracer..tracerVs4  v||~F  2 2r))rr<rFr[rGr<r,z%OutputTracer[MethodicalOutput] | Noner!)rrs` r' wrapTracerrPs=  /  Mr)c\eZdZUedZded<edZded< d d dZy) MethodicalTracerFr=rrjr^riNcVt||j|jdfd }|S)Nc:jt|yr4)setTracer)rrks r'rz*MethodicalTracer.__get__..setTraceos  ! !*V"4 5r))rStringTracer | Noner,r\)rlrirj)r5rhrrrks @r'rzMethodicalTracer.__get__js'1 T^^T  6r)r4)rhrrrr,zCallable[[StringTracer], None])rNr_r`rrjrbrirr!r)r'rrcsKOT PILU#FC#-1#) 'r)rc8dtttzS)z, Create a unique Python identifier. _symbol_)r^nextcounterr!r)r'gensymrxs 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|_yr4)r _automaton _reducersr_symbolrXs 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@rBrD)r<rrf) stateMethodrinitialr5rDs r' decoratorz*MethodicalMachine.state..decorators*#[ZE/4,Lr)r!)r5rterminalrDrs`` ` r'rzMethodicalMachine.states. r)cfd}|S)zM Declare an input. This is a decorator for methods. cHtj|jS)N)rjrBri)r[rr) inputMethodr5s r'rz*MethodicalMachine.input..decorators"//+dll r)r!r5rs` r'rFzMethodicalMachine.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@rB)r) outputMethodr5s r'rz+MethodicalMachine.output..decorators#DF Fr)r!rs` r'rGzMethodicalMachine.outputs Gr)cp|jj|||t|||j|<y)z. See L{MethodicalState.upon}. N)r addTransitionr#r)r5 startState inputTokenendState outputTokensrRs r'rOz MethodicalMachine._oneTransitions6$ %%  HeL.A -6 j)r)cfd}|S) c2tfd}|S)Nct|jj}||jjSr4)rlrrrrD)rhrk decorateer5s r' serializezBMethodicalMachine.serializer..decorator..serializes784<<  ! (;(;(F(FGGr)r)rrr5s` 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}|||_yr4)rstatesrDrlrr) rhrr{rmapping eachStaterkrr5s r' unserializezFMethodicalMachine.unserializer..decorator..unserializesr!%9$9&9!%!7!7!9>I4=GI001>84<<  '.en #r)r)rrr5s` r'rz1MethodicalMachine.unserializer..decorators" 9    r)r!rs` r' unserializerzMethodicalMachine.unserializers r)cBt|j|jSr4)rrrrXs 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.|jjSr4rW)rs r'rz-MethodicalMachine.asDigraph.." (=(=r)c.|jjSr4rW)rFs r'rz-MethodicalMachine.asDigraph..#rr)c.|jjSr4rW)rGs r'rz-MethodicalMachine.asDigraph..$s&--*@*@r)) stateAsString inputAsStringoutputAsString) _visualizerr)r5rs r' asDigraphzMethodicalMachine.asDigraphs$ , OO==@   r)r4)FFN)rrCrrCrDr )r,r)rNr_r`rarrr9rrFrGrOrrpropertyrrr!r)r'r?r?s  TX/3IQ@    6.  (?? r)r?)rhrrir^rjrr,z@Transitioner[MethodicalState, MethodicalInput, MethodicalOutput])r7rAr,r\)rrr,zATracer[MethodicalState, MethodicalInput, MethodicalOutput] | None)7 __future__r collectionssys dataclassesrr functoolsrinspectrr" itertoolsr typingr r r r r version_infotyping_extensionsr_corerrrr_introspectionr namedtuplerr(r1r9rr<rlrnrqrvrrrr[rr^StringOutputTracerrrbrrrrr?r!r)r'r s" (1==g+ @@( +   .. $ $:$f:$:$z  MF $  8 &&R CL CL e/$f/$/$d $$v$$BseTk*P iP F& ev" '+f f r)