h;D\%SSKJr SSKrSSKrSSKJrJr SSKJr SSK J r SSK J r SSKJrJrJrJrJr \R(S:aSS KJr OSS KJr S S KJrJrJrJr S S KJr \R<"S /SQ5rSr Sr!Sr"\"SS9"SS\#55r$S,Sjr%Sr&Sr'S-Sjr(Sr)\"S5r*\"S5r+\"SS9"SS \#55r,\"SS9"S!S"\#55r-\\./S4r/S#r0S$\1S%'S.S&jr2\"SS9"S'S(\#55r3\ "5r4S)r5"S*S+\#5r6g)/) annotationsN) dataclassfieldwraps)getfullargspec)count)AnyCallableHashableIterableTypeVar) ) TypeAlias) Automaton OutputTracerTracer Transitioner) preserveNameArgSpecargsvarargsvarkwdefaults kwonlyargskwonlydefaultsrc [U5n[[UR5URUR UR (a UR OS[UR5UR(a#[URR55OS[URR55S9$)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 Z/root/1688_scrapy/alibaba-scraper/venv/lib/python3.13/site-packages/automat/_methodical.py _getArgSpecr("s t D  499  jj"&--R)262E2EE$%%++- .2$**0023  c[URUR-UR(aSOS-UR(aSOS-[ SUR 55-5$)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**kwargsc3:# UHoSS:wdM Uv M g7f)rreturnNr!).0as r' _getArgNames..Ls@+atx/?+s  )setrrrrr#r)r&s r' _getArgNamesr29sb  // :2 /!JJ=B 0 @4++@ @  A r)c0^[T5U4Sj5nU$)z 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>T"U40UD6$Nr!)selfkwfs r'g_keywords_only..g[s}}r)r)r8r9s` r'_keywords_onlyr;Ps" 1X Hr)T)frozenc\rSrSr%Sr\"SS9rS\S'\"5rS\S'\"SS9r S \S 'S S \ 4SS jjr SS jr Sr g )MethodicalStatebz% A state for a L{MethodicalMachine}. FreprMethodicalMachinemachineCallable[..., Any]methodbool serializedNc UcUnUc/n[UR5nUHn[UR5nURU5(aM0[SR UR R UR R [UR 5[UR 5S95e URRXX#U5 g)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) r2argSpecissubset TypeErrorformatrE__name__r"rC_oneTransition)r6rIenteroutputs collector inputArgsrJ outputArgss r'uponMethodicalState.uponls8 =E ?G / F%fnn5J&&y11228&#ll33%}}55'25<<'@(3FMM(B 393   ##DKr)c.URR$r5rErQr6s r'_nameMethodicalState._name{{###r)r!) rIMethodicalInputrSzMethodicalState | NonerTz!Iterable[MethodicalOutput] | NonerUzCallable[[Iterable[T]], object]r,Noner,str)rQ __module__ __qualname____firstlineno____doc__rrC__annotations__rErGlistrXr]__static_attributes__r!r)r'r>r>bs"'E!2G 2!&F (%(J( )-5959 .L.L&.L3 .L 3 .L  .L`$r)r>ch[XS5nUc"[UUR5n[XU5 U$)z Get a L{Transitioner} N)getattrr initialStatesetattr)oselfsymbol automaton transitioners r'_transitionerFromInstancerss>5$/L#   " "  |, r)cgr5r!r!r)r'_emptyrusr)cg) docstringNr!r!r)r' _docstringrxsr)cURR[RR[RR4;a [ S5eg)Nzfunction body must be empty)__code__co_coderurx ValueError)r8s r' assertNoCoder}sC zz&//"9"9:;N;N;V;V!WW677Xr)c[[URSSU55nUR(aUnO'UVVs/sHupgXcR;dMUPM nnn[U5nUH upXU 4- nM [URSSS2URSSS25n U VVs0sHupgXh;dM Xg_M n nnU R U5 UR (aU n X]4$URSSUR-nU R5VVs0sHupgXn;dM Xg_M n nnX]4$s snnfs snnfs snnf)af 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' _filterArgsrsMs9>>!"-t45J &0HZTQ13GqZ HV}! 5M)"9>>$B$'););DbD)ABH$,JHDA0I414HKJv#   %% (__QR0:3H3HH(..0 0TQA4KDAD0    %%)IK s#D4D4+ D::D: E(ETRF)eqc\rSrSr%Sr\"SS9rS\S'\"5rS\S'\"SS9r S \S '\"\ SS 9r S \S '\"SSS9r S\S'SSjr SSSjjrSSjrSrg)r`z& An input for a L{MethodicalMachine}. Fr@=Automaton[MethodicalState, MethodicalInput, MethodicalOutput]rqrDrErcrp)default_factoryrAz1dict[MethodicalState, Callable[[Iterable[T]], R]] collectors)initrArrMcb[UR5Ul[UR5 gr5)r(rErMr}r\s r' __post_init__MethodicalInput.__post_init__s"4;;/ T[[!r)Nc^^^[TTRTR5m[TR5[ TR5SUUU4Sjj55nU$)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>T R"T /UQ70UD6 T RnT RT 5up4T RUn/nUHNnUbU"U5 [ XT R UR 5upU"T /UQ70U D6n UR U 5 MP U"U5$r5)rE_state transitionrrrMappend)rr previousStaterT outTracerrUvaluesrJr.krror6rrs r'doInput(MethodicalInput.__get__..doInputs KK / / /(//M#/#:#:4#@ W 6IF!(f%"4v~~Nu.q.A. e$ " V$ $r))robjectrrr,r)rsrprqrrEr)r6rotyperrrs`` @r'__get__MethodicalInput.__get__ sS 1 T^^T dkk " t{{  % %  # %r)c.URR$r5r[r\s r'r]MethodicalInput._name&r_r))rMr,rar5)rorrrar,rrb)rQrdrerfrgrrqrhrErpdictrrMrrr]rjr!r)r'r`r`syPU PIL"'F (U#FC#DI5EJA%e4GW4"4$r)r`cx\rSrSr%Sr\"SS9rS\S'S\S'\"SSSS 9rS \S 'SS jr SSjr Sr SSjr Sr g )MethodicalOutputi*z' An output for a L{MethodicalMachine}. Fr@rBrCrDrE)rrAcomparerrMcH[UR5URS'g)NrM)r(rE__dict__r\s r'rMethodicalOutput.__post_init__4s#.t{{#; i r)Ncp[SRURURRS95e)zH 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.)clsrE)AttributeErrorrPrQrEr6rors r'rMethodicalOutput.__get__7s< DDJFMM$++*>*>EKE  r)c.UR"U/UQ70UD6$)z Call the underlying method. )rE)r6rorrs r'__call__MethodicalOutput.__call__Bs{{5242622r)c.URR$r5r[r\s r'r]MethodicalOutput._nameHr_r)r!rr5rb)rQrdrerfrgrrCrhrMrrrr]rjr!r)r'rr*sF"'E!2G 2 %eUCGWC<  3 $r)rz4Callable[[str, str, str], StringOutputTracer | None]r StringTracerc0^TcgSU4SjjnU$)Nc>^T"UR5UR5UR55mTbU4Sj$g)Nc0>T"UR55$r5r])outresults r',wrapTracer..tracer..]svciik2r)r)staterIrJrwrappeds @r'tracerwrapTracer..tracerVs4  v||~F  2 2r))rr>rIr`rJr>r,z%OutputTracer[MethodicalOutput] | Noner!)rrs` r' wrapTracerrPs=  /  Mr)c\\rSrSr%\"SS9rS\S'\"SS9rS\S'S S S jjrS r g) MethodicalTracericFr@rrqrcrpNcX^[XRUR5mSU4SjjnU$)Nc:>TR[U55 gr5)setTracer)rrrs r'r*MethodicalTracer.__get__..setTraceos  ! !*V"4 5r))rStringTracer | Noner,ra)rsrprq)r6rorrrrs @r'rMethodicalTracer.__get__js%1 T^^T  6r)r!r5)rorrrr,zCallable[[StringTracer], None]) rQrdrerfrrqrhrprrjr!r)r'rrcsPOT PILU#FC#-1#) 'r)rc8S[[[55-$)z$ Create a unique Python identifier. _symbol_)rcnextcounterr!r)r'gensymrxs DM* **r)c\rSrSrSrSrSSjr\SSSjj5r\S5r \S5r S r \S 5r \S 5r \SS j5rS rSrg)rBizY A L{MethodicalMachine} is an interface to an L{Automaton} that uses methods on a class. cN[5Ul0Ul[5Ulgr5)r _automaton _reducersr_symbolr\s r'__init__MethodicalMachine.__init__s#+x r)Nc"Ub [S5eU$)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'rMethodicalMachine.__get__s   !QR R r)c^^^UUU4SjnU$)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. cN>[TUTS9nT(aUTRlU$)N)rCrErG)r>rrm) stateMethodrinitialr6rGs r' decorator*MethodicalMachine.state..decorators*#[ZE/4,Lr)r!)r6rterminalrGrs`` ` r'rMethodicalMachine.states. r)c^U4SjnU$)z5 Declare an input. This is a decorator for methods. cB>[TRUTRS9$)N)rqrErp)r`rr) inputMethodr6s r'r*MethodicalMachine.input..decorators"//+dll r)r!r6rs` r'rIMethodicalMachine.inputs  r)c^U4SjnU$)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>[TUS9$)N)rCrE)r) outputMethodr6s r'r+MethodicalMachine.output..decorators#DF Fr)r!rs` r'rJMethodicalMachine.outputs Gr)clURRXU[U55 XRRU'g)z See L{MethodicalState.upon}. N)r addTransitionr#r)r6 startState inputTokenendState outputTokensrUs r'rR MethodicalMachine._oneTransitions2$ %% HeL.A -6j)r)c^U4SjnU$)c4>^[T5UU4Sj5nU$)Nc~>[UTRTR5nT"XRR5$r5)rsrrrrG)rorr decorateer6s r' serializeBMethodicalMachine.serializer..decorator..serializes584<<  !(;(;(F(FGGr)r)rrr6s` r'r/MethodicalMachine.serializer..decorators$ 9  H H  r)r!rs` r' serializerMethodicalMachine.serializers r)c^U4SjnU$)rc4>^[T5UU4Sj5nU$)Nc>T"U/UQ70UD6n0nTRR5HnXTUR'M [UTRTR5nXCUlgr5)rstatesrGrsrr) rorrrmapping eachStaterrrr6s r' unserializeFMethodicalMachine.unserializer..decorator..unserializesi!%9$9&9!%!7!7!9I4=I001":84<<  '.n #r)r)rr r6s` r'r1MethodicalMachine.unserializer..decorators" 9    r)r!rs` r' unserializerMethodicalMachine.unserializers r)cB[URUR5$r5)rrrr\s r' _setTraceMethodicalMachine._setTraces>>r)c:SSKJn U"URSSSS9$)z 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.URR$r5r[)rs r'r-MethodicalMachine.asDigraph.." (=(=r)c.URR$r5r[)rIs r'rr#rr)c.URR$r5r[)rJs r'rr$s&--*@*@r)) stateAsString inputAsStringoutputAsString) _visualizerr)r6rs r' asDigraphMethodicalMachine.asDigraphs$ , OO==@   r))rrrr5)FFN)rrFrrFrGr )r,r)rQrdrerfrgrrr;rrIrJrRrrpropertyrr rjr!r)r'rBrBs  TX/3IQ@    6.  (?? r)rB)rorrprcrqrr,z@Transitioner[MethodicalState, MethodicalInput, MethodicalOutput])r8rDr,ra)rrr,zATracer[MethodicalState, MethodicalInput, MethodicalOutput] | None)7 __future__r collectionssys dataclassesrr functoolsrinspectrr" itertoolsr typingr r r r r version_infotyping_extensionsr_corerrrr_introspectionr namedtuplerr(r2r;rr>rsrurxr}rrrr`rrcStringOutputTracerrrhrrrrrBr!r)r'r1s" (1==g+ @@(    .. $ $:$f:$:$z  MF $  8 &&R CL CL e/$f/$/$d $$v$$BseTk*P iP F& ev" '+f f r)