U

KD�g�a�@s�dd
lZdd
l
Z
ddlmZmZ
ddlmZ
ddlmZ
e
�	e
�
Zeddddg�ZdZ
d	Zd
ZGdd�de�Zddd
�
ZGdd�d�ZGdd�de�ZGdd�de�ZGdd�d�Zd
S)�N)�deque�
namedtuple)
�accepts_kwargs)
�
EVENT_ALIASES�NodeList�first�middle�last�
�c@seZ
dZd
d�ZdS)rc
Cs4t�|j
�
}
t�|j�
}t�|j�
}t|
||�}|S�
N)�copyrrr	r)�selfZ
first_copyZmiddle_copyZ	last_copy�copied�r�;/opt/cppython/lib/python3.8/site-packages/botocore/hooks.py�__copy__s





zNodeList.__copy__N)�__name__�
__module__�__qualname__rrrrrrs
cCs&|D]}|d
dk	r|d

Sq|
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 necessary 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_idr!rrr�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()``.

        rN)r"�_register_firstr$rrr�register_firstls





�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()``.

        rN)r"�_register_lastr$rrr�
register_last~s	




�zBaseEventHooks.register_lastcCs&|�|�

|�
|�

||
|||�
dSr)�_verify_is_callable�_verify_accept_kwargs)rrr%r&r r!rrrr"�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).

        Nrr$rrr�
unregister�szBaseEventHooks.unregistercCst|
�
st
d
|
�d��
�
dS)N�Event handler z must be callable.)�callable�
ValueError�r�funcrrrr,�s

z"BaseEventHooks._verify_is_callablecCs8zt|
�
st
d
|
�d��
�
Wntk
r2


YdSXdS)z�Verifies a callable accepts kwargs

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

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

        r/z) must accept keyword arguments (**kwargs)FN)rr1�	TypeErrorr2rrrr-�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|_dSr)�
_lookup_cache�_PrefixTrie�	_handlers�_unique_id_handlers�
rrrr�__init__�s
zHierarchicalEmitter.__init__FcCs�g}|j�
|
�
}|d
kr0|j�|
�
}||j|
<n|s8gS|
|d<g}|D]>}t�d|
|�
|f|�
}|�||f�

|rH|d
k	rH|
SqH|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)r6�getr8�
prefix_search�logger�debug�append)rrr�stop_on_responserZhandlers_to_callr%rrrr�_emit�s 














zHierarchicalEmitter._emitcKs|�|
|�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.
        �
rBrrrrr�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)
rA���)NNNrC)rrrrrrr�emit_until_response
s


z'HierarchicalEmitter.emit_until_responseNcCs|j|
|||t
d
�
dS�N�
�section)�_register_section�_MIDDLEr$rrrr#
s




�zHierarchicalEmitter._registercCs|j|
|||t
d
�
dSrF)rI�_FIRSTr$rrrr( 
s




�z#HierarchicalEmitter._register_firstcCs|j|
|||t
d
�
dSrF)rI�_LASTr$rrrr*+
s
�z"HierarchicalEmitter._register_lastcCs�|dk	r�||jkrn|j|�
d
d�}|rV|s>td|�d��
�
qj|j|d
d7<n|rjtd|�d��
�
dS|jj|
||d�
d|i
}|r�d|d
<||j|<n|jj|
||d�
i|_dS)	N�countz#Initial registration of  unique id zn was specified to use a counter. Subsequent register calls to unique id must specify use of a counter as well.r
�"Initial registration of unique id zv was specified to not use a counter. Subsequent register calls to unique id must specify not to use a counter as well.rGr%)r9r<r1r8�append_itemr6)rrr%r&r!rHrMZunique_id_handler_itemrrrrI2
s2






�


�
�


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


YdSX|r�|dkrTtd|�d��
�
q�|dkrn|j�|�
d}q�|j|d
d8<dSn$|r�td|�d��
�
|j�|�
d}z|j�|
|�
i|_Wntk
r�


YnXdS)NrMrNzp was specified to use a counter. Subsequent unregister calls to unique id must specify use of a counter as well.r
r%zx was specified to not use a counter. Subsequent unregister calls to unique id must specify not to use a counter as well.)r9r<�KeyErrorr1�popr8�remove_itemr6)rrr%r&r!rMrrrr.^
s4







�


�



�





zHierarchicalEmitter.unregisterc
Cs<|��}
|j
��}t�|j�
|d
<t�|j�
|d<||
_
|
S)Nr8r9)�	__class__�__dict__r
r8r9)rZnew_instance�	new_staterrrr�
s






zHierarchicalEmitter.__copy__)
F)NF)NF)
F)NNF)
rrrr;rBrrEr#r(r*rIr.rrrrrr5�s$


(
�
�
�
/

�
+r5c@sfeZ
dZddd�
Zdd�Zdd�Zdd	d
�
Zddd�
Zdd
d�
Zddd�
Z	dd�Z
dd�Zdd�Zd
S)�EventAliaserNcCs$||_|dkrt
|_i|_|
|_dSr)�_event_aliasesr�_alias_name_cache�_emitter)rZ
event_emitterZ
event_aliasesrrrr;�
s





zEventAliaser.__init__cKs|�|
�
}|j
j|f
|�
Sr)�_alias_event_namerYr�rrr�aliased_event_namerrrr�
s


zEventAliaser.emitcKs|�|
�
}|j
j|f
|�
Sr)rZrYrEr[rrrrE�
s


z EventAliaser.emit_until_responseFcCs|�|
�
}|j
�||||�Sr)rZrYr'�rrr%r&r!r\rrrr'�
s


�zEventAliaser.registercCs|�|
�
}|j
�||||�Sr)rZrYr)r]rrrr)�
s


�zEventAliaser.register_firstcCs|�|
�
}|j
�||||�Sr)rZrYr+r]rrrr+�
s


�zEventAliaser.register_lastcCs|�|
�
}|j
�||||�Sr)rZrYr.r]rrrr.�
s


�zEventAliaser.unregisterc	Cs�|
|jkr|j|
S|j
��D]�\}}|
�d
�
}d
|krfz|||�|�
<Wq�tk
rb


YqYq�Xn$||
kr|�d
�
}|�|||�
nqd
�|�
}t�	d|
�d|���

||j|
<|
S|
|j|
<|
S)N�
.zChanging event name from z to )
rXrW�items�split�indexr1�_replace_subsection�joinr>r?)rrZold_part�new_partZevent_parts�	old_parts�new_namerrrrZ�
s*














�



zEventAliaser._alias_event_namecCsZtt
|
�
�
D]H}|
||d
kr|
||t
|�
�|kr|g
|
||t
|�
�<
dSqdS)Nr
)�range�len)r�sectionsrerd�
irrrrb�
s
��
z EventAliaser._replace_subsectionc

Cs|�t
�
|j�
t
�
|j�
�Sr)rSr
rYrWr:rrrr�
s



�zEventAliaser.__copy__)
N)NF)NF)NF)NNF)
rrrr;rrEr'r)r+r.rZrbrrrrrrV�
s&

�
	�
	�


�
%	rVc@sTeZ
dZd
Zdd�Zef
dd�
Zdd�Zdd	�Zd
d�Z	dd
�Z
dd�Zdd�ZdS)r7ajSpecialized 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)
�_rootr:rrrr;sz_PrefixTrie.__init__cCs�|
�d
�
}|j
}|D]:}||dkrB|did�}||d|<|}q|d|}q|ddkrltggg�|d<|d|�|�

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.
        r^rlN)rkrmrlrm)r`rnrr@)r�key�valuerH�	key_parts�current�part�	new_childrrrrOs









z_PrefixTrie.append_itemcCs*t�}|
�
d
�
}|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").

        r^r
)rr`rn�
_get_items)rro�	collectedrqrrrrrr=,s





z_PrefixTrie.prefix_searchcCs�|
|fg
}t|�
}|r�|�
�\}}|d
rR|d
}	|	j|	j|	j}
|�t|
�
�

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

|dk	r|�||f�

qdS)Nrmrl�
*r
)	rhrQrrr	�
extendleft�reversedr<r@)rZ
starting_noderqrvZstarting_index�stackZ
key_parts_len�current_nodera�	node_listZcomplete_orderrlZdirectsZwildcardZ
next_indexrrrru:s$




�









z_PrefixTrie._get_itemscCs&|
�d
�
}|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.

        r^r
)
raN)r`rn�_remove_item)rrorprqrrrrrrRZs


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

n.||jkr�|j�|�

n||jkr�|j�|�

|d
s�|ds�|
d
||=ntdd�|�
���
�
dS)Nrlr
rmzkey is not in trie: r^)	rhr<r}r�removerr	r1rc)rr{rqrpraZ	next_noder|rrrr}fs"

















z_PrefixTrie._remove_itemc
Cs|��}
|�
|j�
}||
_|
Sr)rS�_recursive_copyrT)rZnew_copyZcopied_attrsrrrr~s


z_PrefixTrie.__copy__cCsVi}|
��D]D\}}t
|t�r.t�|�
||<qt
|t�rH|�|�
||<q|||<q|Sr)r_�
isinstancerr
�dictr)r�nodeZcopied_noderorprrrr�s








z_PrefixTrie._recursive_copyN)
rrr�__doc__r;rJrOr=rurRr}rrrrrrr7�
s
 
r7)
N)r
�logging�collectionsrrZbotocore.compatrZbotocore.utilsr�	getLoggerrr>Z	_NodeListrKrJrLrrrr5rVr7rrrr�<module>
s"






	

Qh