| Server IP : 167.99.254.82 / Your IP : 216.73.216.76 Web Server : Apache System : Linux host.techisquad.com 5.15.0-187-generic #197-Ubuntu SMP Fri Jul 17 19:17:01 UTC 2026 x86_64 User : pawluxera ( 1011) PHP Version : 8.1.34 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON Directory : /lib/python3/dist-packages/botocore/__pycache__/ |
Upload File : |
o
.&�aa � @ s� d dl Z d dlZd dlmZmZ d dlmZmZ d dlm Z e�
e �Z edg d��Z
d ZdZdZG d d� de
�Zdd
d �ZG d d
� d
e�ZG dd� de�ZG dd� de�ZG dd� de�ZdS )� N)�deque�
namedtuple)�accepts_kwargs�six)�
EVENT_ALIASES�NodeList)�first�middle�last� � c @ s e Zd Zdd� ZdS )r c C s4 t � | j�}t � | j�}t � | j�}t|||�}|S �N)�copyr r r
r )�self�
first_copy� middle_copy� last_copy�copied� r �0/usr/lib/python3/dist-packages/botocore/hooks.py�__copy__ s
zNodeList.__copy__N)�__name__�
__module__� __qualname__r r r r r r s c C s& | D ]}|d dur|d S q|S )a Find 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�responser r r �first_non_none_response& s
�r c @ sd e Zd Zdd� Z ddd�Z ddd�Z dd d
�Zd d � Z dd
d�Zdd� Z dd� Z
dS )�BaseEventHooksc K s g S )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�kwargsr r r �emitC s zBaseEventHooks.emitNFc C � | 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�r r �handler� unique_idr& r r r �registerT s
�zBaseEventHooks.registerc C r# )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) r r r �register_firstg s
�z BaseEventHooks.register_firstc C r# )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) r r r �
register_lastt s
�z BaseEventHooks.register_lastc C s& | � |� | �|� |||||� d S r
)�_verify_is_callable�_verify_accept_kwargs)r r r* r+ r% r& r r r r' � s
z#BaseEventHooks._verify_and_registerc C s dS )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 r) r r r �
unregister� s zBaseEventHooks.unregisterc C s t �|�s td| ��d S )Nz"Event handler %s must be callable.)r �callable�
ValueError�r �funcr r r r1 � s
�z"BaseEventHooks._verify_is_callablec C s0 z
t |�s td| ��W dS ty Y dS w )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)r r5 � TypeErrorr6 r r r r2 � s �� �z$BaseEventHooks._verify_accept_kwargs�NF�NNF) r r r r" r, r. r0 r' r3 r1 r2 r r r r r B s"
�
�
�
� r c @ st e Zd Zdd� Zddd�Zdd� Zdd � Z
dd d �Z
dd
d�Z ddd�Z dd� Z
ddd�Z dd� Z d
S )�HierarchicalEmitterc C s i | _ t� | _i | _d S r
)�
_lookup_cache� _PrefixTrie� _handlers�_unique_id_handlers�r r r r �__init__� s
z HierarchicalEmitter.__init__Fc C s� g }| j �|�}|du r| j�|�}|| j |< n|s g S ||d< g }|D ]!}t�d||� |di |��}|�||f� |rE|durE| S q$|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.
Nr z Event %s: calling handler %sr )r< �getr> �
prefix_search�logger�debug�append)r r r! �stop_on_responser �handlers_to_callr* r r r r �_emit� s" �zHierarchicalEmitter._emitc K s | � ||�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.
�rI r r r r r" � s zHierarchicalEmitter.emitc K s | j ||dd�}|r|d S dS )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)rG ���)NNrJ )r r r! r r r r �emit_until_response� s
z'HierarchicalEmitter.emit_until_responseNc C � | j ||||td� d S �N��section)�_register_section�_MIDDLEr) r r r r( � �
�z HierarchicalEmitter._registerc C rM rN )rQ �_FIRSTr) r r r r- � rS z#HierarchicalEmitter._register_firstc C rM rN )rQ �_LASTr) r r r r/ rS z"HierarchicalEmitter._register_lastc C s� |d urL|| j v r3| j | �dd �}|r)|s td| ��| j | d d7 < d S |r1td| ��d S | jj|||d� d|i}|rFd|d< || j |< n | jj|||d� i | _d S )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.rO r* )r? rB r5 r> � append_itemr< )r r r* r+ r& rP rV �unique_id_handler_itemr r r rQ s8
�����
�
z%HierarchicalEmitter._register_sectionc C s� |d urPz | j | �dd �}W n
ty Y d S w |r@|d u r&td| ��|dkr3| j �|�d }n | j | d d8 < d S |rHtd| ��| j �|�d }z
| j�||� i | _W d S tyg Y d S w )NrV z�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? rB �KeyErrorr5 �popr> � remove_itemr< )r r r* r+ r& rV r r r r3 0 s< ����� �z HierarchicalEmitter.unregisterc C s< | � � }| j�� }t�| j�|d< t�| j�|d< ||_|S )Nr> r? )� __class__�__dict__r r> r? )r � new_instance� new_stater r r r R s
z HierarchicalEmitter.__copy__)Fr9 r: )
r r r rA rI r" rL r( r- r/ rQ r3 r r r r r r; � s$
(
�
�
�(
� "r; c @ sv e Zd Zddd�Zdd� Zdd� Z dd d
�Z dd d �Z dd
d�Z ddd�Z dd� Z
dd� Z dd� Z dS )� EventAliaserNc C s$ || _ |d u r
t| _ i | _|| _d S r
)�_event_aliasesr �_alias_name_cache�_emitter)r �
event_emitter�
event_aliasesr r r rA \ s
zEventAliaser.__init__c K � | � |�}| jj|fi |��S r
)�_alias_event_namerc r" �r r r! �aliased_event_namer r r r" c �
zEventAliaser.emitc K rf r
)rg rc rL rh r r r rL g rj z EventAliaser.emit_until_responseFc C � | � |�}| j�||||�S r
)rg rc r, �r r r* r+ r& ri r r r r, k �
�zEventAliaser.registerc C rk r
)rg rc r. rl r r r r. r rm zEventAliaser.register_firstc C rk r
)rg rc r0 rl r r r r0 y rm zEventAliaser.register_lastc C rk r
)rg rc r3 rl r r r r3 � rm zEventAliaser.unregisterc C s� || j v r
| j | S | j�� D ]H\}}|�d�}d|vr/z |||�|�< W n ty. Y qw ||v r@|�d�}| �|||� nqd�|�}t� d||f � || j |< | S || j |< |S )N�.z!Changing event name from %s to %s)
rb ra �items�split�indexr5 �_replace_subsection�joinrD rE )r r �old_part�new_part� event_parts� old_parts�new_namer r r rg � s,
�
�
z EventAliaser._alias_event_namec C sZ t t|��D ]$}|| |d kr*|||t|� � |kr*|g|||t|� �< d S qd S )Nr )�range�len)r �sectionsrw ru �ir r r rr � s ��z EventAliaser._replace_subsectionc C s | � t�| j�t�| j��S r
)r\ r rc ra r@ r r r r � s
�zEventAliaser.__copy__r
r9 r: )
r r r rA r" rL r, r. r0 r3 rg rr r r r r r r` [ s&
�
�
�
�& r` c @ sT e Zd ZdZdd� Zefdd�Zdd� Zdd � Zd
d � Z d d
� Z
dd� Z dd� Z dS )r= aj Specialized 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 C s d i d d�| _ d S )N)�chunk�children�values)�_rootr@ r r r rA � s z_PrefixTrie.__init__c C s� |� d�}| j}|D ] }||d vr!|di d�}||d |< |}q
|d | }q
|d du r6tg g g �|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.
rn r~ N)r} r r~ r )rp r� r rF )r �key�valuerP � key_parts�current�part� new_childr r r rW � s
z_PrefixTrie.append_itemc C s* 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").
rn r )r rp r� �
_get_items)r r� � collectedr� r� r r r rC � s
z_PrefixTrie.prefix_searchc C s� ||fg}t |�}|r[|�� \}}|d r)|d } | j| j | j }
|�t|
�� ||ksW|d } | �|| �} | �d�}
|d }|
d urL|�|
|f� | d urW|�| |f� |s d S d S )Nr r~ �*r ) rz rZ r r r
�
extendleft�reversedrB rF )r �
starting_noder� r� �starting_index�stack�
key_parts_len� current_noderq � node_list�complete_orderr~ �directs�wildcard�
next_indexr r r r� � s&
�
�z_PrefixTrie._get_itemsc C s& |� 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.
rn r )rq N)rp r� � _remove_item)r r� r� r� r� r r r r[ s
z_PrefixTrie.remove_itemc C s� |d u rd S |t |�k rp|d �|| �}|d urg| �||||d � |t |�d krR|d }||jv r;|j�|� n||jv rG|j�|� n ||jv rR|j�|� |d sc|d se|d || = d S d S d S tdd�|� ��d S )Nr~ r r zkey is not in trie: %srn ) rz rB r� r �remover r
r5 rs )r r� r� r� rq � next_noder� r r r r� ( s*
� ��z_PrefixTrie._remove_itemc C s | � � }| �| j�}||_|S r
)r\ �_recursive_copyr] )r �new_copy� copied_attrsr r r r A s z_PrefixTrie.__copy__c C sV i }|� � D ]"\}}t|t�rt�|�||< qt|t�r$| �|�||< q|||< q|S r
)ro �
isinstancer r �dictr� )r �node� copied_noder� r� r r r r� K s
z_PrefixTrie._recursive_copyN)
r r r �__doc__rA rR rW rC r� r[ r� r r� r r r r r= � s
r= r
)r �logging� collectionsr r �botocore.compatr r �botocore.utilsr � getLoggerr rD � _NodeListrT rR rU r r �objectr r; r` r= r r r r �<module> s"
d 6b