U b6{i[C @sUddlmZddlZddlZddlmZmZddlmZddl m Z ddl m Z ddlmZmZmZmZmZejdkrdd lmZn dd lmZd d lmZmZmZmZd d lmZed dddddddgZddZ ddZ!ddZ"eddGddde#Z$dd d!d"d#d$d%Z%d&d'Z&d(d)Z'd*d+d,d-d.Z(d/d0Z)ed1Z*ed2Z+ed3d4Gd5d6d6e#Z,eddGd7d8d8e#Z-ee.gdfZ/d9Z0d:e1d;<dd?d@Z2ed3d4GdAdBdBe#Z3e Z4dCdDZ5GdEdFdFe#Z6dS)G) annotationsN) dataclassfieldwraps)getfullargspec)count)AnyCallableHashableIterableTypeVar) ) TypeAlias) Automaton OutputTracerTracer Transitioner) preserveNameArgSpecargsvarargsvarkwdefaults kwonlyargskwonlydefaultsrc CsXt|}tt|j|j|j|jr&|jndt|j|jrDt|j ndt|j dS)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 )rrrrrrr) getArgsSpecrtuplerrrrrritemsr)funcspecrr7/tmp/pip-unpacked-wheel-3c4m1_88/automat/_methodical.py _getArgSpec"s  r%cCs2t|j|j|jrdnd|jr$dnd|jS)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#rrr$ _getArgNames9s   r'cstfdd}|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. cs |f|SNr)selfkwfrr$gWsz_keywords_only..gr)r,r-rr+r$_keywords_onlyLs r.T)frozenc@speZdZUdZeddZded<eZded<eddZded <d d e fd d d dddddZ ddddZ d S)MethodicalStatez- A state for a L{MethodicalMachine}. FreprMethodicalMachinemachineCallable[..., Any]methodbool serializedNMethodicalInputzMethodicalState | Nonez!Iterable[MethodicalOutput] | NonezCallable[[Iterable[T]], object]None)inputenteroutputs collectorreturncCs|dkr |}|dkrg}t|j}|D]B}t|j}||s&tdj|jj|jjt|jt|jdq&|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})r;outputZinputSignatureZoutputSignature) r'argSpecissubset TypeErrorformatr6__name__rr4_oneTransition)r)r;r<r=r>Z inputArgsr@Z outputArgsrrr$uponhs"    zMethodicalState.uponstrr?cCs|jjSr(r6rEr)rrr$_nameszMethodicalState._name) rE __module__ __qualname____doc__rr4__annotations__r6r8listrGrLrrrr$r0^s 0r0objectrH=Automaton[MethodicalState, MethodicalInput, MethodicalOutput]z@Transitioner[MethodicalState, MethodicalInput, MethodicalOutput])oselfsymbol automatonr?cCs0t||d}|dkr,t||j}t||||S)z Get a L{Transitioner} N)getattrr initialStatesetattr)rTrUrV transitionerrrr$_transitionerFromInstances  r[cCsdSr(rrrrr$_emptysr\cCsdS)Z docstringNrrrrr$ _docstringsr]r5r:)r,r?cCs$|jjtjjtjjfkr tddS)Nzfunction body must be empty)__code__co_coder\r] ValueErrorr+rrr$ assertNoCodes rac stt|jdd|}jr$|}nfdd|D}t||D]\}}||f7qBt|jddd|jddd}fdd|D} | |jr| } n*jddjfdd| 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] rNcsg|]\}}|jkr|qSr)r.0nv) outputSpecrr$ s z_filterArgs..csi|]\}}|kr||qSrrrb)passed_arg_namesrr$ sz_filterArgs..csi|]\}}|kr||qSrrrb)all_accepted_namesrr$rjs) r ziprrrupdaterrr!) rkwargsZ inputSpecrfZ named_argsZ return_argsnamevaluerZ full_kwargsZ return_kwargsr)rkrfrir$ _filterArgss"  "  rqTRF)eqc@seZdZUdZeddZded<eZded<eddZded <ee dd Z d ed <eddd Z ded<ddddZ dddddddZ ddddZdS)r9z. An input for a L{MethodicalMachine}. Fr1rSrVr5r6rHrU)default_factoryr2z1dict[MethodicalState, Callable[[Iterable[T]], R]] collectors)initr2rrAr:rIcCst|j|_t|jdSr()r%r6rArarKrrr$ __post_init__s zMethodicalInput.__post_init__NrRrTtyper?csBtjjtjtjddddfdd }|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. rR)rrnr?c sjf||j}\}}j|}g}|D]D}|dk rL||t||j|j\}} |f|| } || q8||Sr()r6_stateZ transitionrvrqrAappend) rrnZ previousStater=Z outTracerr>valuesr@akrprTr)rZrr$doInputs  z(MethodicalInput.__get__..doInput)r[rUrVrr6r)r)rTrzrrrr$__get__s zMethodicalInput.__get__cCs|jjSr(rJrKrrr$rL"szMethodicalInput._name)N)rErMrNrOrrVrPr6rUdictrvrArxrrLrrrr$r9s r9c@speZdZUdZeddZded<ded<eddddZd ed <d d d dZdddZ ddZ dd ddZ dS)MethodicalOutputz/ An output for a L{MethodicalMachine}. Fr1r3r4r5r6)rwr2comparerrAr:rIcCst|j|jd<dS)NrA)r%r6__dict__rKrrr$rx0szMethodicalOutput.__post_init__NcCstdj|j|jjddS)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.)clsr6N)AttributeErrorrDrEr6r)rTrzrrr$r3s zMethodicalOutput.__get__cOs|j|f||S)z- Call the underlying method. )r6)r)rTrrnrrr$__call__>szMethodicalOutput.__call__rHcCs|jjSr(rJrKrrr$rLDszMethodicalOutput._name)N) rErMrNrOrr4rPrArxrrrLrrrr$r&s  rz4Callable[[str, str, str], StringOutputTracer | None]r StringTracerStringTracer | NonezATracer[MethodicalState, MethodicalInput, MethodicalOutput] | None)wrappedr?cs(dkr dSdddddfdd }|S)Nr0r9z%OutputTracer[MethodicalOutput] | None)stater;r@r?cs0|||dk r,fddSdS)Ncs |Sr(rL)outresultrr$Yz,wrapTracer..tracer..r)rr;r@rrr$tracerRs zwrapTracer..tracerr)rrrrr$ wrapTracerLs rc@sFeZdZUeddZded<eddZded<d ddd d d d ZdS)MethodicalTracerFr1rSrVrHrUNrRzCallable[[StringTracer], None]rycs(t||j|jdddfdd }|S)Nrr:)rr?cst|dSr()setTracer)rrZrr$rksz*MethodicalTracer.__get__..setTrace)r[rUrV)r)rTrzrrrr$rfszMethodicalTracer.__get__)N)rErMrNrrVrPrUrrrrr$r_s rcCsdtttS)z, Create a unique Python identifier. Z_symbol_)rHnextcounterrrrr$gensymtsrc@seZdZdZddZdddZedddd d d d Zed dZeddZ ddZ eddZ eddZ e ddddZddZdS)r3ze A L{MethodicalMachine} is an interface to an L{Automaton} that uses methods on a class. cCst|_i|_t|_dSr()r _automatonZ _reducersr_symbolrKrrr$__init__szMethodicalMachine.__init__NcCs|dk rtd|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.)rrrrr$rszMethodicalMachine.__get__Fr7r )initialterminalr8csfdd}|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. cst|d}r|j_|S)N)r4r6r8)r0rrX)Z stateMethodrrr)r8rr$ decoratorsz*MethodicalMachine.state..decoratorr)r)rrr8rrrr$rszMethodicalMachine.statecsfdd}|S)zM Declare an input. This is a decorator for methods. cstj|jdS)N)rVr6rU)r9rr)Z inputMethodrKrr$rs z*MethodicalMachine.input..decoratorrr)rrrKr$r;s zMethodicalMachine.inputcsfdd}|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. cs t|dS)N)r4r6)r)Z outputMethodrKrr$rsz+MethodicalMachine.output..decoratorrrrrKr$r@s zMethodicalMachine.outputcCs$|j|||t|||j|<dS)z. See L{MethodicalState.upon}. N)rZ addTransitionr rv)r)Z startStateZ inputTokenZendStateZ outputTokensr>rrr$rFsz MethodicalMachine._oneTransitioncsfdd}|S) cstfdd}|S)Ncst|jj}||jjSr()r[rrr{r8)rTrZ decorateer)rr$ serializes zBMethodicalMachine.serializer..decorator..serializer)rrrKrr$rsz/MethodicalMachine.serializer..decoratorrrrrKr$ serializers zMethodicalMachine.serializercsfdd}|S)rcstfdd}|S)NcsL|f||}i}jD]}|||j<qt|jj}|||_dSr()rZstatesr8r[rr{)rTrrnrmappingZ eachStaterZrrr$ unserializes  zFMethodicalMachine.unserializer..decorator..unserializer)rrrKrr$rs z1MethodicalMachine.unserializer..decoratorrrrrKr$ unserializers zMethodicalMachine.unserializerrrIcCst|j|jSr()rrrrKrrr$ _setTrace szMethodicalMachine._setTracecCs*ddlm}||jdddddddS)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) makeDigraphcSs|jjSr(rJ)rrrr$rrz-MethodicalMachine.asDigraph..cSs|jjSr(rJ)r;rrr$rrcSs|jjSr(rJ)r@rrr$r r)Z stateAsStringZ inputAsStringZoutputAsString)Z _visualizerr)r)rrrr$ asDigraphs zMethodicalMachine.asDigraph)N)FFN)rErMrNrOrrr.rr;r@rFrrpropertyrrrrrr$r3{s(      r3)7 __future__r collectionssysZ dataclassesrr functoolsrinspectrr itertoolsrtypingr r r r r version_infoZtyping_extensionsrZ_corerrrrZ_introspectionr namedtuplerr%r'r.rRr0r[r\r]rarqrrrsr9rrHZStringOutputTracerrrPrrrrr3rrrr$s`       =)2!