3

�T_�_�@s�dd
lZdd
l
Z
ddlmZmZmZ
ddlmZmZ
ddl	m
Z

e
je�
Z
eddddg�ZdZd	Zd
ZGdd�de�Zddd
�
ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�Zd
S)�N)�defaultdict�deque�
namedtuple)�accepts_kwargs�six)
�
EVENT_ALIASES�NodeList�first�middle�last�
�c@seZ
dZd
d�ZdS)rc
Cs4tj|j
�
}
tj|j�
}tj|j�
}t|
||�}|S)
N)�copyr	r
rr)�selfZ
first_copyZmiddle_copyZ	last_copyZcopied�r�/usr/lib/python3.6/hooks.py�__copy__s





zNodeList.__copy__N)�__name__�
__module__�__qualname__rrrrrrscCs&x |D]}|d
dk	r|d
SqW|
S)aFind first non None response in a list of tuples.

    This function can be used to find the first non None response from
    handlers connected to an event.  This is useful if you are interested
    in the returned responses from event handlers. Example usage::

        print(first_non_none_response([(func1, None), (func2, 'foo'),
                                       (func3, 'bar')]))
        # This will print 'foo'

    :type responses: list of tuples
    :param responses: The responses from the ``EventHooks.emit`` method.
        This is a list of tuples, and each tuple is
        (handler, handler_response).

    :param default: If no non-None responses are found, then this default
        value will be returned.

    :return: The first non-None response in the list of tuples.

    rNr)�	responses�default�responserrr�first_non_none_response&s



rc@sTeZ
dZd
d�Zddd�
Zddd�
Zdd	d
�
Zdd�Zdd
d�
Zdd�Z	dd�Z
dS)�BaseEventHooksc
KsgS)
a�
Call all handlers subscribed to an event.

        :type event_name: str
        :param event_name: The name of the event to emit.

        :type **kwargs: dict
        :param **kwargs: Arbitrary kwargs to pass through to the
            subscribed handlers.  The ``event_name`` will be injected
            into the kwargs so it's not necesary to add this to **kwargs.

        :rtype: list of tuples
        :return: A list of ``(handler_func, handler_func_return_value)``

        r)r�
event_name�kwargsrrr�emitCszBaseEventHooks.emitNFcCs|j|
|||j
|d
�
dS)a@Register an event handler for a given event.

        If a ``unique_id`` is given, the handler will not be registered
        if a handler with the ``unique_id`` has already been registered.

        Handlers are called in the order they have been registered.
        Note handlers can also be registered with ``register_first()``
        and ``register_last()``.  All handlers registered with
        ``register_first()`` are called before handlers registered
        with ``register()`` which are called before handlers registered
        with ``register_last()``.

        )�register_method�unique_id_uses_countN)�_verify_and_register�	_register)rr�handler�	unique_idrrrr�registerTs


zBaseEventHooks.registercCs|j|
|||j
|d
�
dS)z�Register an event handler to be called first for an event.

        All event handlers registered with ``register_first()`` will
        be called before handlers registered with ``register()`` and
        ``register_last()``.

        )rrN)r �_register_first)rrr"r#rrrr�register_firstgs	


zBaseEventHooks.register_firstcCs|j|
|||j
|d
�
dS)z�Register an event handler to be called last for an event.

        All event handlers registered with ``register_last()`` will be called
        after handlers registered with ``register_first()`` and ``register()``.

        )rrN)r �_register_last)rrr"r#rrrr�
register_lastts


zBaseEventHooks.register_lastcCs&|j|�

|j
|�

||
|||�
dS)
N)�_verify_is_callable�_verify_accept_kwargs)rrr"r#rrrrrr �s



z#BaseEventHooks._verify_and_registerc
Csd
S)z�Unregister an event handler for a given event.

        If no ``unique_id`` was given during registration, then the
        first instance of the event handler is removed (if the event
        handler has been registered multiple times).

        Nr)rrr"r#rrrr�
unregister�s	zBaseEventHooks.unregistercCstj
|
�
std
|
�
�
dS)Nz"Event handler %s must be callable.)r�callable�
ValueError)r�funcrrrr)�s


z"BaseEventHooks._verify_is_callablecCs2yt|
�
st
d
|
�
�
Wntk
r,


dSXdS)z�Verifies a callable accepts kwargs

        :type func: callable
        :param func: A callable object.

        :returns: True, if ``func`` accepts kwargs, otherwise False.

        z9Event handler %s must accept keyword arguments (**kwargs)FN)rr-�	TypeError)rr.rrrr*�s	




z$BaseEventHooks._verify_accept_kwargs)NF)NF)NF)NNF)rrrrr$r&r(r r+r)r*rrrrrBs









rc@sfeZ
dZd
d�Zddd�
Zdd�Zdd	�Zddd�
Zdd
d�
Zddd�
Z	dd�Z
ddd�
Zdd�Zd
S)�HierarchicalEmitterc

Csi|_t
�|_i|_dS)
N)�
_lookup_cache�_PrefixTrie�	_handlers�_unique_id_handlers)
rrrr�__init__�s
zHierarchicalEmitter.__init__FcCs�g}|jj
|
�
}|d
kr0|jj|
�
}||j|
<n|s8gS|
|d<g}xB|D]:}tjd|
|�
|f|�
}|j||f�

|rJ|d
k	rJ|SqJW|S)a�
        Emit an event with optional keyword arguments.

        :type event_name: string
        :param event_name: Name of the event
        :type kwargs: dict
        :param kwargs: Arguments to be passed to the handler functions.
        :type stop_on_response: boolean
        :param stop_on_response: Whether to stop on the first non-None
                                response. If False, then all handlers
                                will be called. This is especially useful
                                to handlers which mutate data and then
                                want to stop propagation of the event.
        :rtype: list
        :return: List of (handler, response) tuples from all processed
                 handlers.
        NrzEvent %s: calling handler %s)r1�getr3�
prefix_search�logger�debug�append)rrr�stop_on_responserZhandlers_to_callr"rrrr�_emit�s 














zHierarchicalEmitter._emitcKs|j|
|�S)
a;

        Emit an event by name with arguments passed as keyword args.

            >>> responses = emitter.emit(
            ...     'my-event.service.operation', arg1='one', arg2='two')

        :rtype: list
        :return: List of (handler, response) tuples from all processed
                 handlers.
        )
r<)rrrrrrr�szHierarchicalEmitter.emitcKs$|j|
|d
d�}|r|dSdSdS)a�

        Emit an event by name with arguments passed as keyword args,
        until the first non-``None`` response is received. This
        method prevents subsequent handlers from being invoked.

            >>> handler, response = emitter.emit_until_response(
                'my-event.service.operation', arg1='one', arg2='two')

        :rtype: tuple
        :return: The first (handler, response) tuple where the response
                 is not ``None``, otherwise (``None``, ``None``).
        T)
r;rN���)NN)
r<)rrrrrrr�emit_until_response�s


z'HierarchicalEmitter.emit_until_responseNcCs|j|
|||t
d
�
dS)N)
�section)�_register_section�_MIDDLE)rrr"r#rrrrr!�s

zHierarchicalEmitter._registercCs|j|
|||t
d
�
dS)N)
r?)r@�_FIRST)rrr"r#rrrrr%�s

z#HierarchicalEmitter._register_firstcCs|j|
|||t
d
�
dS)N)
r?)r@�_LAST)rrr"r#rrrrr'
s

z"HierarchicalEmitter._register_lastcCs�|dk	r�||jkrf|j|j
d
d�}|rR|s:td|�
�
qb|j|d
d7<n|rbtd|�
�
dS|jj|
||d�
d|i
}|r�d|d
<||j|<n|jj|
||d�
i|_dS)N�countz�Initial registration of  unique id %s was specified to use a counter. Subsequent register calls to unique id must specify use of a counter as well.rz�Initial registration of unique id %s was specified to not use a counter. Subsequent register calls to unique id must specify not to use a counter as well.)
r?r")r4r6r-r3�append_itemr1)rrr"r#rr?rDZunique_id_handler_itemrrrr@
s,















z%HierarchicalEmitter._register_sectioncCs�|dk	r�y|j|j
d
d�}Wntk
r2


dSX|r�|dkrNtd|�
�
q�|dkrh|jj|�
d}q�|j|d
d8<dSn |r�td|�
�
|jj|�
d}y|jj|
|�
i|_Wntk
r�


YnXdS)NrDz�Initial registration of unique id %s was specified to use a counter. Subsequent unregister calls to unique id must specify use of a counter as well.rr"z�Initial registration of unique id %s was specified to not use a counter. Subsequent unregister calls to unique id must specify not to use a counter as well.)r4r6�KeyErrorr-�popr3�remove_itemr1)rrr"r#rrDrrrr+0
s0



















zHierarchicalEmitter.unregisterc
Cs<|j�}
|j
j�}tj|j�
|d
<tj|j�
|d<||
_
|
S)Nr3r4)�	__class__�__dict__rr3r4)rZnew_instanceZ	new_staterrrrR
s






zHierarchicalEmitter.__copy__)
F)NF)NF)
F)NNF)
rrrr5r<rr>r!r%r'r@r+rrrrrr0�s


(





(

!r0c@sfeZ
dZddd�
Zdd�Zdd�Zdd	d
�
Zddd�
Zdd
d�
Zddd�
Z	dd�Z
dd�Zdd�Zd
S)�EventAliaserNcCs||_|dkrt
|_|
|_dS)
N)�_event_aliasesr�_emitter)rZ
event_emitterZ
event_aliasesrrrr5\
s



zEventAliaser.__init__cKs|j|
�
}|j
j|f
|�
S)
N)�_alias_event_namerMr)rrr�aliased_event_namerrrrb
s


zEventAliaser.emitcKs|j|
�
}|j
j|f
|�
S)
N)rNrMr>)rrrrOrrrr>f
s


z EventAliaser.emit_until_responseFcCs|j|
�
}|j
j||||�S)
N)rNrMr$)rrr"r#rrOrrrr$j
s


zEventAliaser.registercCs|j|
�
}|j
j||||�S)
N)rNrMr&)rrr"r#rrOrrrr&q
s


zEventAliaser.register_firstcCs|j|
�
}|j
j||||�S)
N)rNrMr()rrr"r#rrOrrrr(x
s


zEventAliaser.register_lastcCs|j|
�
}|j
j||||�S)
N)rNrMr+)rrr"r#rrOrrrr+
s


zEventAliaser.unregisterc
Cs�x�|jj
�D]�\}}|
jd
�
}d
|krRy|||j|�
<Wqvtk
rN


wYqvXn$||
kr|jd
�
}|j|||�
nqd
j|�
}tjd|
|f�

|SW|
S)N�
.z!Changing event name from %s to %s)	rL�items�split�indexr-�_replace_subsection�joinr8r9)rrZold_part�new_partZevent_parts�	old_parts�new_namerrrrN�
s 













zEventAliaser._alias_event_namecCs\xVtt
|
�
�
D]F}|
||d
kr|
||t
|�
�|kr|g
|
||t
|�
�<dSqWdS)Nr
)�range�len)rZsectionsrWrV�
irrrrT�
s





z EventAliaser._replace_subsectionc

Cs|jt
j
|j�
t
j
|j�
�S)
N)rIrrMrL)
rrrrr�
s



zEventAliaser.__copy__)
N)NF)NF)NF)NNF)
rrrr5rr>r$r&r(r+rNrTrrrrrrK[
s









 rKc@sTeZ
dZd
Zdd�Zef
dd�
Zdd�Zdd	�Zd
d�Z	dd
�Z
dd�Zdd�ZdS)r2ajSpecialized prefix trie that handles wildcards.

    The prefixes in this case are based on dot separated
    names so 'foo.bar.baz' is::

        foo -> bar -> baz

    Wildcard support just means that having a key such as 'foo.bar.*.baz' will
    be matched with a call to ``get_items(key='foo.bar.ANYTHING.baz')``.

    You can think of this prefix trie as the equivalent as defaultdict(list),
    except that it can do prefix searches:

        foo.bar.baz -> A
        foo.bar -> B
        foo -> C

    Calling ``get_items('foo.bar.baz')`` will return [A + B + C], from
    most specific to least specific.

    c

Csdidd
�|_dS)N)�chunk�children�values)
�_root)
rrrrr5�
sz_PrefixTrie.__init__cCs�|
jd
�
}|j
}xB|D]:}||dkrD|did�}||d|<|}q|d|}qW|ddkrptggg�|d<|d|j|�

dS)z�Add an item to a key.

        If a value is already associated with that key, the new
        value is appended to the list for the key.
        rPr]N)r\r^r]r^)rRr_rr:)r�key�valuer?�	key_parts�current�part�	new_childrrrrE�
s










z_PrefixTrie.append_itemcCs*t�}|
j
d
�
}|j}|j|||d�
|S)z�Collect all items that are prefixes of key.

        Prefix in this case are delineated by '.' characters so
        'foo.bar.baz' is a 3 chunk sequence of 3 "prefixes" (
        "foo", "bar", and "baz").

        rPr
)rrRr_�
_get_items)rr`�	collectedrbrcrrrr7�
s





z_PrefixTrie.prefix_searchcCs�|
|fg
}t|�
}x�|r�|j
�\}}|d
rT|d
}	|	j|	j|	j}
|jt|
�
�

||ks|d}|j||�
}|jd�
}
|d}|
dk	r�|j|
|f�

|dk	r|j||f�

qWdS)Nr^r]�
*r)	rZrGr	r
r�
extendleft�reversedr6r:)rZ
starting_noderbrgZstarting_index�stackZ
key_parts_len�current_noderS�	node_listZcomplete_orderr]ZdirectsZwildcardZ
next_indexrrrrf�
s$


















z_PrefixTrie._get_itemscCs&|
jd
�
}|j
}|j|||dd�
dS)z�Remove an item associated with a key.

        If the value is not associated with the key a ``ValueError``
        will be raised.  If the key does not exist in the trie, a
        ``ValueError`` will be raised.

        rPr
)
rSN)rRr_�_remove_item)rr`rarbrcrrrrHs


z_PrefixTrie.remove_itemcCs�|
dkrdS|t|�
kr�|
d
j
||�
}|dk	r�|j||||d�
|t|�
dkr�|d}||jkrv|jj|�

n.||jkr�|jj|�

n||jkr�|jj|�

|d
r�|dr�|
d
||=ntddj|�
�
�
dS)Nr]rr^zkey is not in trie: %srP)	rZr6rnr	�remover
rr-rU)rrlrbrarSZ	next_nodermrrrrns$


















z_PrefixTrie._remove_itemc
Cs|j�}
|j
|j�
}||
_|
S)
N)rI�_recursive_copyrJ)rZnew_copyZcopied_attrsrrrr7s


z_PrefixTrie.__copy__cCsZi}xP|
j�D]D\}}t
|t�r0tj|�
||<qt
|t�rJ|j|�
||<q|||<qW|S)
N)rQ�
isinstancerr�dictrp)rZnodeZcopied_noder`rarrrrpAs







z_PrefixTrie._recursive_copyN)
rrr�__doc__r5rArEr7rfrHrnrrprrrrr2�
s

r2)
N)rZlogging�collectionsrrrZbotocore.compatrrZbotocore.utilsrZ	getLoggerrr8Z	_NodeListrBrArCrr�objectrr0rKr2rrrr�<module>
s 









d6Y