o

*we�a�@s�dd
lZdd
l
Z
ddlmZmZ
ddlmZ
ddlmZ
e
�	e
�
Zedgd�
�ZdZ
dZdZGd	d�de�Zdd
d�
ZGdd
�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)�self�
first_copy�middle_copy�	last_copy�copied�r�G/home/arjun/projects/env/lib/python3.10/site-packages/botocore/hooks.py�__copy__s





zNodeList.__copy__N)�__name__�
__module__�__qualname__rrrrrrs
cCs&|D]}|d
du
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@s`eZ
dZd
d�Z	ddd�
Z	ddd�
Z	dd	d
�
Zdd�Z			dd
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.emitNFcC�|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.registercCr")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()``.

        r#N)r&�_register_firstr(rrr�register_firstls






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

        r#N)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|
�
s
t
d
|
�
�
dS)Nz"Event handler %s must be callable.)�callable�
ValueError�r�funcrrrr0�s

�z"BaseEventHooks._verify_is_callablecCs4zt|
�
s
t
d
|
�d��
�
WdSty


YdSw)z�Verifies a callable accepts kwargs

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

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

        zEvent handler z) must accept keyword arguments (**kwargs)FN)rr4�	TypeErrorr5rrrr1�s	



��
�z$BaseEventHooks._verify_accept_kwargs�NF�NNF)rrrr!r+r-r/r&r2r0r1rrrrrBs

�
�
�


�rc@sreZ
dZd
d�Zddd�
Zdd�Zdd	�Z	ddd�
Z	dd
d�
Z	ddd�
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
ur|j�|
�
}||j|
<n|sgS|
|d<g}|D]!}t�d|
|�
|di|�
�
}|�||f�

|rE|d
u
rE|
Sq$|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 %sr)r;�getr=�
prefix_search�logger�debug�append)rrr �stop_on_responser�handlers_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.
        �
rHrrrrr!�szHierarchicalEmitter.emitcKs |j|
|d
d�}|r|dSdS)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)
rF���)NNrI)rrr rrrr�emit_until_response
s


z'HierarchicalEmitter.emit_until_responseNcC�|j|
|||t
d
�
dS�N�
�section)�_register_section�_MIDDLEr(rrrr'
�





�zHierarchicalEmitter._registercCrLrM)rP�_FIRSTr(rrrr, 
rRz#HierarchicalEmitter._register_firstcCrLrM)rP�_LASTr(rrrr.+
s


�z"HierarchicalEmitter._register_lastcCs�|du
rL||jvr3|j|�
d
d�}|r)|std|�
�
|j|d
d7<dS|r1td|�
�
dS|jj|
||d�
d|i
}|rFd|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.rNr))r>rAr4r=�append_itemr;)rrr)r*r%rOrU�unique_id_handler_itemrrrrP2
s8





��	�

��
�



z%HierarchicalEmitter._register_sectioncCs�|du
rPz|j|�
d
d�}Wn
ty


YdSw|r@|dur&td|�
�
|dkr3|j�|�
d}n|j|d
d8<dS|rHtd|�
�
|j�|�
d}z
|j�|
|�
i|_WdStyg


YdSw)NrUz�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.)r>rA�KeyErrorr4�popr=�remove_itemr;)rrr)r*r%rUrrrr2^
s@


�


��


�


��




�zHierarchicalEmitter.unregisterc
Cs<|��}
|j
��}t�|j�
|d
<t�|j�
|d<||
_
|
S)Nr=r>)�	__class__�__dict__r
r=r>)r�new_instance�	new_staterrrr�
s






zHierarchicalEmitter.__copy__)
Fr8r9)
rrrr@rHr!rKr'r,r.rPr2rrrrrr:�s"


(

�
�
�/


�+r:c@sreZ
dZddd�
Zdd�Zdd�Z	dd	d
�
Z	ddd�
Z	dd
d�
Z	
	
	ddd�
Z	dd�Z
dd�Zdd�Zd
S)�EventAliaserNcCs$||_|dur
t
|_i|_|
|_dSr)�_event_aliasesr�_alias_name_cache�_emitter)r�
event_emitter�
event_aliasesrrrr@�
s






zEventAliaser.__init__cK�|�|
�
}|j
j|f
i|�
�
Sr)�_alias_event_namerbr!�rrr �aliased_event_namerrrr!�
�


zEventAliaser.emitcKrer)rfrbrKrgrrrrK�
riz EventAliaser.emit_until_responseFcC�|�|
�
}|j
�||||�Sr)rfrbr+�rrr)r*r%rhrrrr+�
�


�zEventAliaser.registercCrjr)rfrbr-rkrrrr-�
rlzEventAliaser.register_firstcCrjr)rfrbr/rkrrrr/�
rlzEventAliaser.register_lastcCrjr)rfrbr2rkrrrr2�
s


�zEventAliaser.unregisterc	Cs�|
|jvr
|j|
S|j
��D]J\}}|
�d
�
}d
|v
r/z	|||�|�
<Wnty.


Yqw||
vr@|�d
�
}|�|||�
n
qd
�|�
}t�	d|
�d|���

||j|
<|
S|
|j|
<|
S)N�
.zChanging event name from z to )
rar`�items�split�indexr4�_replace_subsection�joinrCrD)rr�old_part�new_part�event_parts�	old_parts�new_namerrrrf�
s,








�





�



zEventAliaser._alias_event_namecCsZtt
|
�
�
D]$}|
||d
kr*|
||t
|�
�|kr*|g
|
||t
|�
�<
dSqdS)Nr
)�range�len)r�sectionsrvrt�
irrrrq�
s


��z EventAliaser._replace_subsectionc

Cs|�t
�
|j�
t
�
|j�
�Sr)r[r
rbr`r?rrrr�
s

�zEventAliaser.__copy__rr8r9)
rrrr@r!rKr+r-r/r2rfrqrrrrrr_�
s"


�	
�	
�


�%	r_c@sTeZ
dZd
Zdd�Zef
dd�
Zdd�Zdd	�Zd
d�Z	dd
�Z
dd�Zdd�ZdS)r<ajSpecialized 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]}||dv
r!|did�}||d|<|}q
|d|}q
|ddur6tggg�|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.
        rmr}N)r|r~r}r~)rorrrE)r�key�valuerO�	key_parts�current�part�	new_childrrrrVs









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").

        rmr
)rror�
_get_items)rr��	collectedr�r�rrrrB,s





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

||ksW|d}|�||�
}|�d�
}
|d}|
du
rL|�|
|f�

|du
rW|�||f�

|sdSdS)Nr~r}�
*r
)	ryrYrrr	�
extendleft�reversedrArE)r�
starting_noder�r��starting_index�stack�
key_parts_len�current_noderp�	node_list�complete_orderr}�directs�wildcard�
next_indexrrrr�: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.

        rmr
)
rpN)ror�_remove_item)rr�r�r�r�rrrrZZs


z_PrefixTrie.remove_itemcCs�|
durdS|t|�
krq|
d
�
||�
}|du
rg|�||||d�
|t|�
dkrR|d}||jvr;|j�|�

n||jvrG|j�|�

n||jvrR|j�|�

|d
sc|dse|
d
||=dSdSdStdd�|�
���
�
dS)Nr}r
r~zkey is not in trie: rm)	ryrAr�r�removerr	r4rr)rr�r�r�rp�	next_noder�rrrr�fs&

















��z_PrefixTrie._remove_itemc
Cs|��}
|�
|j�
}||
_|
Sr)r[�_recursive_copyr\)r�new_copy�copied_attrsrrrr~s


z_PrefixTrie.__copy__cCsVi}|
��D]"\}}t
|t�rt�|�
||<qt
|t�r$|�|�
||<q|||<q|Sr)rn�
isinstancerr
�dictr�)r�node�copied_noder�r�rrrr��s








z_PrefixTrie._recursive_copyN)
rrr�__doc__r@rQrVrBr�rZr�rr�rrrrr<�
s
 
r<r)r
�logging�collectionsrr�botocore.compatr�botocore.utilsr�	getLoggerrrC�	_NodeListrSrQrTrrrr:r_r<rrrr�<module>
s$







	
Qh