File: //proc/self/root/usr/lib/python3/dist-packages/automat/__pycache__/_methodical.cpython-38.pyc
U
Ձ�]<> �
@ sn d dl Z d dlmZ d dlmZ zd dlmZ W n ek
rP d dlm Z Y nX d dl
Z
d dl Z ddl m
Z
mZ ddlmZ e �d d
d d d
dddg�Zdd� Zdd� Zdd� Ze
jdd�G dd� de��Zdd � Zd d � Zd d � Zd!d"� Z d#d$� Z e
jd%d%d&�G d'd(� d(e��Z e
jdd�G d)d*� d*e��Z e
jd%d%d&�G d+d,� d,e��Z e� Z!d-d.� Z"G d/d0� d0e�Z#dS )1� N��wraps)�count)�getfullargspec)�
getargspec� )� Transitioner� Automaton)� preserveName�ArgSpec�args�varargs�varkw�defaults�
kwonlyargs�kwonlydefaults� annotationsc
C s� t | �}tt|j�|jtjr"|jn|j|j r2|j ndtjrDt|j
�ndtjrd|j r`t|j � � �qfdndtjrzt|j
� � �ndd�S )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 r
r r r r r )� getArgsSpecr �tupler r
�sixZPY3r �keywordsr r r �itemsr )�func�specr r �5/usr/lib/python3/dist-packages/automat/_methodical.py� _getArgSpec s ����r c C s2 t | j| j | jrdnd | jr$dnd | j �S )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)�setr r r
r r )r r r r � _getArgNames2 s
� � ���r c s t � �� fdd��}|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 s � | f|�S �Nr )�self�kw��fr r �gO s z_keywords_only.<locals>.gr )r# r$ r r" r �_keywords_onlyE s
r% T)�frozenc @ sD e Zd ZdZejdd�Ze�� Zejdd�Ze fdd�Z
dd� Z dS ) �MethodicalStatez-
A state for a L{MethodicalMachine}.
F��reprc C sj t |j�}|D ]B}t |j�}|�|�stdj|jj|jjt|j�t|j�d���q| j� | ||||� dS )ac
Declare a state transition within the :class:`automat.MethodicalMachine`
associated with this :class:`automat.MethodicalState`:
upon the receipt of the `input`, enter the `state`,
emitting each output in `outputs`.
:param MethodicalInput input: The input triggering a state transition.
:param MethodicalState enter: The resulting state.
:param Iterable[MethodicalOutput] outputs: The outputs to be triggered
as a result of the declared state transition.
:param Callable 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.
zdmethod {input} signature {inputSignature} does not match output {output} signature {outputSignature})�input�outputZinputSignatureZoutputSignatureN)
r �argSpec�issubset� TypeError�format�method�__name__r �machine�_oneTransition)r r* Zenter�outputs� collectorZ inputArgsr+ Z
outputArgsr r r �upon^ s
�� zMethodicalState.uponc C s | j jS r �r0 r1 �r r r r �_name� s zMethodicalState._nameN) r1 �
__module__� __qualname__�__doc__�attr�ibr2 r0 �
serialized�listr6 r9 r r r r r' U s "r' c C s0 t | |d�}|dkr,t||j�}t| ||� |S )z
Get a L{Transitioner}
N)�getattrr � initialState�setattr)�oself�symbol� automaton� transitionerr r r �_transitionerFromInstance� s � rH c C s d S r r r r r r �_empty� s rI c C s dS )Z docstringNr r r r r �
_docstring� s rJ c C s$ |j jtj jtj jfkr td��d S )Nzfunction body must be empty)�__code__�co_coderI rJ �
ValueError)�instZ attributer# r r r � assertNoCode� s �rO c s� t t|jdd� | ��}�jr$| }n�fdd�|D �}t |��|D ]\}}�||f7 �qBt|jddd� |jddd� �}�fdd�|D �} | �|� �jr�| }
n*�jdd� �j � � fdd�| �� 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]
r Nc s g | ]\}}|� j kr|�qS r )r ��.0�n�v)�
outputSpecr r �
<listcomp>� s
z _filterArgs.<locals>.<listcomp>���c s i | ]\}}|� kr||�qS r r rP )�passed_arg_namesr r �
<dictcomp>� s z _filterArgs.<locals>.<dictcomp>c s i | ]\}}|� kr||�qS r r rP )�all_accepted_namesr r rX � s � ) r �zipr r
r �updater r r ) r �kwargsZ inputSpecrT Z
named_argsZ return_args�name�valuer Z full_kwargsZ
return_kwargsr )rY rT rW r � _filterArgs� s "
r_ F)Zcmp�hashc @ sv e Zd ZdZejdd�Zejed�Zejdd�Z eje�
e �dd�Z ejddd�Z
e
jdd� �Zdd
d �Zd d
� Zd S )�MethodicalInputz.
An input for a L{MethodicalMachine}.
Fr( )Z validator)�defaultr) �Zinitr) c C s
t | j�S r �r r0 r8 r r r �
_buildArgSpec� s z MethodicalInput._buildArgSpecNc s8 t � �j�j��t�j�t�j�� ��fdd���}|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.
c s� �j � f| �|� �j}����\}}�j| }g }|D ]D}|rL||�� � t| |�j|j�\}} |� f|�| �}
|�|
� q8||�S r )r0 �_stateZ
transition�
collectorsr9 r_ r, �append) r r\ Z
previousStater4 Z outTracerr5 �valuesr+ �a�kr^ �rD r rG r r �doInput� s
z(MethodicalInput.__get__.<locals>.doInput)rH rE rF r
r0 r )r rD �typerm r rl r �__get__� s �
zMethodicalInput.__get__c C s | j jS r r7 r8 r r r r9 � s zMethodicalInput._name)N)r1 r: r; r< r= r> rF rO r0 rE ZFactory�dictrg r, rb re ro r9 r r r r ra � s
ra c @ sZ e Zd ZdZejdd�Ze�� Zejddd�Zej dd� �Z
ddd �Z d
d � Z d d
� Z
dS )�MethodicalOutputz/
An output for a L{MethodicalMachine}.
Fr( rc c C s
t | j�S r rd r8 r r r re s z MethodicalOutput._buildArgSpecNc C s t dj|j| jjd���dS )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.)�clsr0 N)�AttributeErrorr/ r1 r0 �r rD rn r r r ro
s ��zMethodicalOutput.__get__c O s | j |f|�|�S )z-
Call the underlying method.
)r0 )r rD r r\ r r r �__call__ s zMethodicalOutput.__call__c C s | j jS r r7 r8 r r r r9 s zMethodicalOutput._name)N)r1 r: r; r< r= r> r2 r0 r, rb re ro ru r9 r r r r rq � s
rq c @ s. e Zd Zejdd�Zejdd�Zddd�ZdS )�MethodicalTracerFr( Nc s t || j| j�� � fdd�}|S )Nc s � � | � d S r )�setTrace)Ztracer�rG r r rw ) s z*MethodicalTracer.__get__.<locals>.setTrace)rH rE rF )r rD rn rw r rx r ro & s
� zMethodicalTracer.__get__)N)r1 r: r; r= r> rF rE ro r r r r rv s rv c C s dt tt�� S )z,
Create a unique Python identifier.
Z_symbol_)�str�next�counterr r r r �gensym0 s r| c @ s| e Zd ZdZdd� Zddd�Zeddd ��Zed
d � �Zed d
� �Z dd� Z
edd� �Z edd� �Z e
dd� �Zdd� ZdS )�MethodicalMachinezj
A :class:`MethodicalMachine` is an interface to an `Automaton`
that uses methods on a class.
c C s t � | _i | _t� | _d S r )r �
_automatonZ _reducersr| �_symbolr8 r r r �__init__> s zMethodicalMachine.__init__Nc C s |dk rt d��| 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.)rs rt r r r ro D s
�zMethodicalMachine.__get__Fc s � ��fdd�}|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 bool initial: is this state the initial state?
Only one state on this :class:`automat.MethodicalMachine`
may be an initial state; more than one is an error.
:param bool 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 Hashable serialized: a serializable value
to be used to represent this state to external systems.
This value should be hashable;
:py:func:`unicode` is a good type to use.
c s t �| �d�}� r|�j_|S )N)r2 r0 r? )r' r~ rB )Z stateMethod�state��initialr r? r r � decoratorf s �z*MethodicalMachine.state.<locals>.decoratorr )r r� Zterminalr? r� r r� r r� P s zMethodicalMachine.statec s � fdd�}|S )zM
Declare an input.
This is a decorator for methods.
c s t � j| � jd�S )N)rF r0 rE )ra r~ r )Z inputMethodr8 r r r� w s �z*MethodicalMachine.input.<locals>.decoratorr �r r� r r8 r r* p s zMethodicalMachine.inputc s � fdd�}|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 s t � | d�S )N)r2 r0 )rq )Z outputMethodr8 r r r� � s z+MethodicalMachine.output.<locals>.decoratorr r� r r8 r r+ ~ s
zMethodicalMachine.outputc C s$ | j �|||t|�� ||j|< dS )z.
See L{MethodicalState.upon}.
N)r~ Z
addTransitionr rg )r Z
startStateZ
inputTokenZendStateZ outputTokensr5 r r r r3 � s �z MethodicalMachine._oneTransitionc s � fdd�}|S )�
c s t � �� �fdd��}|S )Nc s t | �j�j�}� | |jj�S r )rH r r~ rf r? )rD rG �� decorateer r r � serialize� s �zBMethodicalMachine.serializer.<locals>.decorator.<locals>.serializer )r� r� r8 �r� r r� � s z/MethodicalMachine.serializer.<locals>.decoratorr r� r r8 r �
serializer� s z MethodicalMachine.serializerc s � fdd�}|S )r� c s t � �� �fdd��}|S )Nc sL � | f|�|�}i }�j �� D ]}|||j< q t| �j�j �}|| |_d S r )r~ Zstatesr? rH r rf )rD r r\ r� �mappingZ eachStaterG r� r r � unserialize� s �
zFMethodicalMachine.unserializer.<locals>.decorator.<locals>.unserializer )r� r� r8 r� r r� � s z1MethodicalMachine.unserializer.<locals>.decoratorr r� r r8 r � unserializer� s z MethodicalMachine.unserializerc C s t | j| j�S r )rv r~ r r8 r r r � _setTrace� s zMethodicalMachine._setTracec C s* ddl m} || jdd� dd� dd� d�S )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<https://graphviz.readthedocs.io/>}
r )� makeDigraphc S s | j jS r r7 )r� r r r �<lambda>� � z-MethodicalMachine.asDigraph.<locals>.<lambda>c S s | j jS r r7 )r* r r r r� � r� c S s | j jS r r7 )r+ r r r r� � r� )Z
stateAsStringZ
inputAsStringZoutputAsString)Z
_visualizer� r~ )r r� r r r � asDigraph� s
�zMethodicalMachine.asDigraph)N)FFN)r1 r: r; r< r� ro r% r� r* r+ r3 r� r� �propertyr� r� r r r r r} 8 s&
�
r} )$� collections� functoolsr � itertoolsr �inspectr r � ImportErrorr r= r Z_corer r Z_introspectionr
�
namedtupler r r r% �s�objectr' rH rI rJ rO r_ ra rq rv r{ r| r} r r r r �<module> sF �
.( +
"