dh;DUddlmZddlZddlZddlmZmZddlmZddl m Z ddl m Z ddlmZmZmZmZmZejdkrdd lmZndd lmZd d lmZmZmZmZd d lmZejd gdZdZ dZ!dZ"edGdde#Z$d:dZ%dZ&d Z'd;d$Z(d%Z)ed&Z*ed'Z+ed()Gd*d+e#Z,edGd,d-e#Z-ee.gdfZ/d.Z0d/e1d0<dz_getArgNames..Ls0@@aqtx/?/?/?/?/?/?@@r))setrrrrr#r)r&s r' _getArgNamesr19sr  /  -::2 /!J .==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[sq}}}}r)r)r7r8s` r'_keywords_onlyr9Ps5 1XXX Hr)T)frozenceZdZUdZedZded<eZded<edZded <d d e fddZ ddZ d S)MethodicalStatez- A state for a L{MethodicalMachine}. FreprMethodicalMachinemachineCallable[..., Any]methodbool serializedNinputMethodicalInputenterMethodicalState | Noneoutputs!Iterable[MethodicalOutput] | None collectorCallable[[Iterable[T]], object]r,Nonec ||}|g}t|j}|D]}t|j}||s^td|jj|jjt|jt|j|j |||||dS)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})rEoutputinputSignatureoutputSignature) r1argSpecissubset TypeErrorformatrB__name__r"r@_oneTransition)r5rErGrIrK inputArgsrO outputArgss r'uponzMethodicalState.uponls8 =E ?G //   F%fn55J&&y11 228&#l3%}5'25<'@'@(3FM(B(B 3933     ##D%KKKKKr)strc|jjSr4rBrVr5s r'_namezMethodicalState._name {##r)) rErFrGrHrIrJrKrLr,rMr,r[) rV __module__ __qualname____doc__rr@__annotations__rBrDlistrZr_r!r)r'r<r<bs"'E!2!2!2G2222!&F((((u%(((J(((( )-5959 .L.L.L.L.L`$$$$$$r)r<oselfobjectsymbolr[ automaton=Automaton[MethodicalState, MethodicalInput, MethodicalOutput]r,@Transitioner[MethodicalState, MethodicalInput, MethodicalOutput]cxt||d}|&t||j}t||||S)z Get a L{Transitioner} N)getattrr initialStatesetattr)rgrirj transitioners r'_transitionerFromInstancerrsM5&$//L#   "   v|,,, r)cdSr4r!r!r)r'_emptyrtsDr)cdS) docstringNr!r!r)r' _docstringrwsr)r7rArMc|jjtjjtjjfvrt ddS)Nzfunction body must be empty)__code__co_codertrw ValueError)r7s r' assertNoCoder|s< z&/"9:;N;V!WWW6777XWr)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)r-nv outputSpecs r' z_filterArgs..s)HHHTQ1 3G3Gq3G3G3Gr)c$i|] \}}|v || Sr!r!)r-rrpassed_arg_namess r' z_filterArgs..s*JJJDAq9I0I0I1a0I0I0Ir)c$i|] \}}|v || Sr!r!)r-rrall_accepted_namess r'rz_filterArgs..s1   QA9K4K4KAq4K4K4Kr)) r#ziprrrupdaterrr$) rkwargs inputSpecr named_args return_argsnamevaluer full_kwargs return_kwargsrrs ` @@r' _filterArgsrsPs9>!""-t4455JI IHHHZHHH V}}!** eT5M)9>$$B$');DDbD)ABBHJJJJHJJJKv # (_QRR0:3HH    (..00     %%r)TRF)eqceZdZUdZedZded<eZded<edZded <ee d Z d ed <edd Z ded<ddZ dddZ ddZdS)rFz. An input for a L{MethodicalMachine}. Fr=rkrjrArBr[ri)default_factoryr>z1dict[MethodicalState, Callable[[Iterable[T]], R]] collectors)initr>rrRr,rMc`t|j|_t|jdSr4)r(rBrRr|r^s r' __post_init__zMethodicalInput.__post_init__s)"4;// T[!!!!!r)Nrgrhtypectjjtjt 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. rrhrr,c< j g|Ri| j}  \}} j|}g}|D]O}| ||t || j|j\}} | g|Ri| } || P||Sr4)rB_state transitionrrrRappend)rr previousStaterI outTracerrKvaluesrOr.krrgr5rqs r'doInputz(MethodicalInput.__get__..doInputs DK / / / / / / /(/M#/#:#:4#@#@ Wi 6IF! % %(If%%%"4v~NN1u.q...A.. e$$$$9V$$ $r))rrhrrhr,rh)rrrirjrrBr)r5rgrrrqs`` @r'__get__zMethodicalInput.__get__ su 1 T^TT dk " " t{   % % % % % % %   # " %r)c|jjSr4r]r^s r'r_zMethodicalInput._name&r`r)r,rMr4)rgrhrrMr,rhra)rVrbrcrdrrjrerBridictrrRrrr_r!r)r'rFrFs PUu PPPI"'F((((%U###F####DIE5EEEJu%e444G4444""""4$$$$$$r)rFceZdZUdZedZded<ded<edddZd ed <dd ZddZ dZ ddZ dS)MethodicalOutputz/ An output for a L{MethodicalMachine}. Fr=r?r@rArB)rr>comparerrRr,rMc>t|j|jd<dS)NrR)r(rB__dict__r^s r'rzMethodicalOutput.__post_init__4s#.t{#;#; i   r)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.)clsrB)AttributeErrorrUrVrBr5rgrs r'rzMethodicalOutput.__get__7s@ DDJFM$+*>EKEE   r)c$|j|g|Ri|S)z- Call the underlying method. )rB)r5rgrrs r'__call__zMethodicalOutput.__call__Bs&t{5242226222r)r[c|jjSr4r]r^s r'r_zMethodicalOutput._nameHr`r)rr4ra) rVrbrcrdrr@rerRrrrr_r!r)r'rr*s"'E!2!2!2G2222u%eUCCCGCCCC<<<<     333 $$$$$$r)rz4Callable[[str, str, str], StringOutputTracer | None]r StringTracerwrappedStringTracer | NoneATracer[MethodicalState, MethodicalInput, MethodicalOutput] | NonecdSd fd }|S) Nstater<rErFrOr,%OutputTracer[MethodicalOutput] | Nonec|||fdSdS)Nc>|Sr4r_)outresults r'z,wrapTracer..tracer..]svvciikk22r)r)rrErOrrs @r'tracerzwrapTracer..tracerVsK  v||~~FF  2222 2tr))rr<rErFrOr<r,rr!)rrs` r' wrapTracerrPs4t Mr)c`eZdZUedZded<edZded< ddd ZdS)MethodicalTracerFr=rkrjr[riNrgrhrr,Callable[[StringTracer], None]cJt||j|jdfd }|S)Nrrr,rMcLt|dSr4)setTracer)rrqs r'rz*MethodicalTracer.__get__..setTraceos%  ! !*V"4"4 5 5 5 5 5r))rrr,rM)rrrirj)r5rgrrrqs @r'rzMethodicalTracer.__get__js?1 T^TT  6 6 6 6 6 6r)r4)rgrhrrhr,r)rVrbrcrrjrerirr!r)r'rrcsOTu PPPI%U###F####-1r)rcJdtttzS)z, Create a unique Python identifier. _symbol_)r[nextcounterr!r)r'gensymrxs DMM** **r)ceZdZdZdZddZe ddd Zed Zed Z dZ edZ edZ e ddZdZdS)r?ze A L{MethodicalMachine} is an interface to an L{Automaton} that uses methods on a class. c`t|_i|_t|_dSr4)r _automaton _reducersr_symbolr^s 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 r'rzMethodicalMachine.__get__s   !QRR R r)FinitialrCterminalrDr 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. cHt|}r |j_|S)N)r@rBrD)r<rro) stateMethodrrr5rDs r' decoratorz*MethodicalMachine.state..decorators7#[ZE 5/4,Lr)r!)r5rrrDrs`` ` r'rzMethodicalMachine.states0.       r)cfd}|S)zM Declare an input. This is a decorator for methods. c<tj|jS)N)rjrBri)rFrr) inputMethodr5s r'rz*MethodicalMachine.input..decorators%"/+dl r)r!r5rs` r'rEzMethodicalMachine.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. c&t|S)N)r@rB)r) outputMethodr5s r'rz+MethodicalMachine.output..decorators#DFFF Fr)r!rs` r'rOzMethodicalMachine.outputs) G G G G Gr)cn|j|||t|||j|<dS)z. See L{MethodicalState.upon}. N)r addTransitionr#r)r5 startState inputTokenendState outputTokensrKs r'rWz MethodicalMachine._oneTransitionsD$ %%  HeL.A.A   -6 j)))r)cfd}|S) c@tfd}|S)Ncft|jj}||jjSr4)rrrrrrD)rgrq decorateer5s r' serializezBMethodicalMachine.serializer..decorator..serializes784<   !y (;(FGGGr)r)rrr5s` r'rz/MethodicalMachine.serializer..decoratorsC 9   H H H H H  H  r)r!rs` r' serializerzMethodicalMachine.serializers$     r)cfd}|S)rc@tfd}|S)Nc|g|Ri|}i}jD] }|||j< t|jj}|||_dSr4)rstatesrDrrrr) rgrrrmapping eachStaterqrr5s r' unserializezFMethodicalMachine.unserializer..decorator..unserializes! %9$999&99!%!7!7!9!9>>I4=GI01184<   '.en #tr)r)rrr5s` r'rz1MethodicalMachine.unserializer..decorators= 9          r)r!rs` r' unserializerzMethodicalMachine.unserializers$     r)r,rc6t|j|jSr4)rrrr^s 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|jjSr4r])rs r'rz-MethodicalMachine.asDigraph.."  (=r)c|jjSr4r])rEs r'rz-MethodicalMachine.asDigraph..#rr)c|jjSr4r])rOs r'rz-MethodicalMachine.asDigraph..$s &-*@r)) stateAsString inputAsStringoutputAsString) _visualizerr)r5rs r' asDigraphzMethodicalMachine.asDigraphsF ,+++++{ O====@@     r)r4)FFN)rrCrrCrDr )r,r)rVrbrcrdrrr9rrErOrWrrpropertyrrr!r)r'r?r?s    TX^@  ^   ^ 666.  ^ ^(???X?     r)r?)rgrhrir[rjrkr,rl)r7rAr,rM)rrr,r)7 __future__r collectionssys dataclassesrr functoolsrinspectrr" itertoolsr typingr r r r r version_infotyping_extensionsr_corerrrr_introspectionr namedtuplerr(r1r9rhr<rrrtrwr|rrrrFrr[StringOutputTracerrrerrrrr?r!r)r'rs|""""""" ((((((((111111==============g+++++++      @@@@@@@@@@@@(((((( +    ..   $ $:$:$:$:$:$f:$:$:$z$    8 8 8 8 &&&&&&R GCLL GCLL e/$/$/$/$/$f/$/$/$d $$$$$$v$$$BseTk*P PPPP& ev" %''+++f f f f f f f f f f r)