403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.217.85
Web Server : Apache
System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64
User : sws1074145052 ( 1074145052)
PHP Version : 8.3.32
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /lib/python3/dist-packages/pip/_vendor/tenacity/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /lib/python3/dist-packages/pip/_vendor/tenacity/__pycache__/wait.cpython-311.pyc
�

�/�cK���ddlZddlZddlZddlmZddlmZejrddlmZej	e
eefZdedefd�Z
Gd�d	ej��ZGd
�de��ZGd�d
e��ZGd�de��ZGd�de��ZGd�de��ZGd�de��ZGd�de��ZGd�de��ZGd�de��ZdS)�N)�	timedelta)�_utils)�RetryCallState�	wait_unit�returnc�r�tt|t��r|���n|��S�N)�float�
isinstancer�
total_seconds)rs �;/usr/lib/python3/dist-packages/pip/_vendor/tenacity/wait.py�
to_secondsrs1���j��I�.N�.N�]��(�(�*�*�*�T]�^�^�^�c�j�eZdZdZejdddefd���Zdd�Zddde	j
d	fd
�ZdS)
�	wait_basez(Abstract base class for wait strategies.�retry_staterrc��dSr	���selfrs  r
�__call__zwait_base.__call__%s���r�other�wait_combinec�"�t||��Sr	)r�rrs  r
�__add__zwait_base.__add__)s���D�%�(�(�(r)rrc�<�|dkr|S|�|��S�Nr)rrs  r
�__radd__zwait_base.__radd__,s"���A�:�:��K��|�|�E�"�"�"rN)rrrr)�__name__�
__module__�__qualname__�__doc__�abc�abstractmethodr
rr�typing�Unionrrrr
rr"s�������2�2���
�$4�
��
�
�
���
�)�)�)�)�#�k�#�f�l�;V�.W�#�#�#�#�#�#rrc�2�eZdZdZdeddfd�Zdddefd�ZdS)	�
wait_fixedzCWait strategy that waits a fixed amount of time between each retry.�waitrNc�.�t|��|_dSr	)rr))rr*s  r
�__init__zwait_fixed.__init__6s��$�T�*�*����rrrc��|jSr	)r)rs  r
rzwait_fixed.__call__9s
����r�r r!r"r#�wait_unit_typer,r
rrrr
r)r)3s_������M�M�+�^�+��+�+�+�+��$4��������rr)c�$��eZdZdZd�fd�Z�xZS)�	wait_nonez7Wait strategy that doesn't wait at all before retrying.rNc�J��t���d��dSr)�superr,)r�	__class__s �r
r,zwait_none.__init__@s!���
����������r)rN)r r!r"r#r,�
__classcell__�r4s@r
r1r1=sC�������A�A����������rr1c�8�eZdZdZddededdfd�Zd	d
defd�ZdS)
�wait_randomzAWait strategy that waits a random amount of time between min/max.r��min�maxrNc�V�t|��|_t|��|_dSr	)r�wait_random_min�wait_random_max)rr:r;s   r
r,zwait_random.__init__Gs$��)�#�����)�#������rrrc�X�|jtj��|j|jz
zzSr	)r=�randomr>rs  r
rzwait_random.__call__Ks'���#�v�}���$�:N�QU�Qe�:e�'f�g�gr)rr9r.rrr
r8r8Dss������K�K�/�/�N�/�^�/�D�/�/�/�/�h�$4�h��h�h�h�h�h�hrr8c�2�eZdZdZdeddfd�Zdddefd�ZdS)	rz#Combine several waiting strategies.�
strategiesrNc��||_dSr	)�
wait_funcs�rrBs  r
r,zwait_combine.__init__R�
��$����rrrc�D��t�fd�|jD����S)Nc3�0�K�|]}|����V��dS)�rNr)�.0�xrs  �r
�	<genexpr>z(wait_combine.__call__.<locals>.<genexpr>Vs0�����G�G�!�1�1��-�-�-�G�G�G�G�G�Gr)�sumrDrs `r
rzwait_combine.__call__Us(����G�G�G�G�t��G�G�G�G�G�Gr�r r!r"r#rr,r
rrrr
rrOsg������-�-�%�I�%�$�%�%�%�%�H�$4�H��H�H�H�H�H�Hrrc�2�eZdZdZdeddfd�Zdddefd�ZdS)	�
wait_chaina�Chain two or more waiting strategies.

    If all strategies are exhausted, the very last strategy is used
    thereafter.

    For example::

        @retry(wait=wait_chain(*[wait_fixed(1) for i in range(3)] +
                               [wait_fixed(2) for j in range(5)] +
                               [wait_fixed(5) for k in range(4)))
        def wait_chained():
            print("Wait 1s for 3 attempts, 2s for 5 attempts and 5s
                   thereafter.")
    rBrNc��||_dSr	)rBrEs  r
r,zwait_chain.__init__irFrrrc��tt|jd��t|j����}|j|dz
}||���S)Nr9rI)r:r;�attempt_number�lenrB)rr�wait_func_no�	wait_funcs    r
rzwait_chain.__call__lsL���3�{�9�1�=�=�s�4�?�?S�?S�T�T���O�L�1�$4�5�	��y�[�1�1�1�1rrNrrr
rPrPYsc������
�
�%�I�%�$�%�%�%�%�2�$4�2��2�2�2�2�2�2rrPc	�L�eZdZdZddejfdedededdfd	�Zd
ddefd�Z	dS)
�wait_incrementingz�Wait an incremental amount of time after each attempt.

    Starting at a starting value and incrementing by a value for each attempt
    (and restricting the upper limit to some maximum value).
    r�d�start�	incrementr;rNc�~�t|��|_t|��|_t|��|_dSr	)rrZr[r;)rrZr[r;s    r
r,zwait_incrementing.__init__ys3�� ��&�&��
�#�I�.�.����c�?�?����rrrc�|�|j|j|jdz
zz}tdt	||j����S�Nr9r)rZr[rSr;r:)rr�results   r
rzwait_incrementing.__call__�s9����t�~��1K�a�1O�P�Q���1�c�&�$�(�+�+�,�,�,r)
r r!r"r#r�MAX_WAITr/r,r
rrrr
rXrXrs���������!"�$'�$�o�	#�#��#�"�#��	#�

�#�#�#�#�-�$4�-��-�-�-�-�-�-rrXc��eZdZdZdejddfdejee	fde
dejee	fde
d	d
f
d�Zdd
d	e	fd�Zd
S)�wait_exponentialaWait strategy that applies exponential backoff.

    It allows for a customized multiplier and an ability to restrict the
    upper and lower limits to some maximum and minimum value.

    The intervals are fixed (i.e. there is no jitter), so this strategy is
    suitable for balancing retries against latency when a required resource is
    unavailable for an unknown duration, but *not* suitable for resolving
    contention between multiple processes for a shared resource. Use
    wait_random_exponential for the latter case.
    r9�r�
multiplierr;�exp_baser:rNc�r�||_t|��|_t|��|_||_dSr	)rdrr:r;re)rrdr;rer:s     r
r,zwait_exponential.__init__�s0��%����c�?�?����c�?�?��� ��
�
�
rrrc���	|j|jdz
z}|j|z}n#t$r
|jcYSwxYwt	t	d|j��t||j����Sr^)rerSrd�
OverflowErrorr;r:)rr�expr_s    r
rzwait_exponential.__call__�sw��	��-�K�$>��$B�C�C��_�s�*�F�F���	�	�	��8�O�O�O�	�����3�q�$�(�#�#�S����%:�%:�;�;�;s��3�3)
r r!r"r#rr`r&r'�intr
r/r,rrrr
rbrb�s�������
�
�01�$�o�-.��
!�
!��L��e��,�
!��
!��,�s�E�z�*�	
!�
�
!�
�
!�
!�
!�
!�<�$4�<��<�<�<�<�<�<rrbc�,��eZdZdZdddef�fd�Z�xZS)�wait_random_exponentialaRandom wait with exponentially widening window.

    An exponential backoff strategy used to mediate contention between multiple
    uncoordinated processes for a shared resource in distributed systems. This
    is the sense in which "exponential backoff" is meant in e.g. Ethernet
    networking, and corresponds to the "Full Jitter" algorithm described in
    this blog post:

    https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/

    Each retry occurs at a random time in a geometrically expanding interval.
    It allows for a custom multiplier and an ability to restrict the upper
    limit of the random interval to some maximum value.

    Example::

        wait_random_exponential(multiplier=0.5,  # initial window 0.5s
                                max=60)          # max 60s timeout

    When waiting for an unavailable resource to become available again, as
    opposed to trying to resolve contention for a shared resource, the
    wait_exponential strategy (which uses a fixed interval) may be preferable.

    rrrc�r��t���|���}tjd|��S)NrIr)r3rr@�uniform)rr�highr4s   �r
rz wait_random_exponential.__call__�s/����w�w���K��8�8���~�a��&�&�&r)r r!r"r#r
rr5r6s@r
rlrl�sV���������2'�$4�'��'�'�'�'�'�'�'�'�'�'rrlc�R�eZdZdZdejddfdededededd	f
d
�Zdddefd
�Zd	S)�wait_exponential_jitterabWait strategy that applies exponential backoff and jitter.

    It allows for a customized initial wait, maximum wait and jitter.

    This implements the strategy described here:
    https://cloud.google.com/storage/docs/retry-strategy

    The wait time is min(initial * (2**n + random.uniform(0, jitter)), maximum)
    where n is the retry count.
    r9rc�initialr;re�jitterrNc�>�||_||_||_||_dSr	)rrr;rers)rrrr;rerss     r
r,z wait_exponential_jitter.__init__�s$�������� ��
�����rrrc���tjd|j��}	|j|jdz
z}|j|z|z}n#t$r
|j}YnwxYwtdt||j����S)Nrr9)	r@rnrsrerSrrrhr;r:)rrrsrir_s     r
rz wait_exponential_jitter.__call__�s������4�;�/�/��	��-�K�$>��$B�C�C��\�C�'�&�0�F�F���	�	�	��X�F�F�F�	�����1�c�&�$�(�+�+�,�,�,s�<�A�A)	r r!r"r#rr`r
r,rrrr
rqrq�s�������	�	���_���
�
��
��
��	
�
�
�
�
�
�
�
�-�$4�-��-�-�-�-�-�-rrq)r$r@r&�datetimer�pip._vendor.tenacityr�
TYPE_CHECKINGrr'rjr
r/r�ABCrr)r1r8rrPrXrbrlrqrrr
�<module>rzs`��"�
�
�
�
�
�
�
�
�
�
�
�������'�'�'�'�'�'�	��4�3�3�3�3�3�3���c�5�)�3�4��_�.�_�U�_�_�_�_�#�#�#�#�#���#�#�#�"��������������
����h�h�h�h�h�)�h�h�h�H�H�H�H�H�9�H�H�H�2�2�2�2�2��2�2�2�2-�-�-�-�-�	�-�-�-�,<�<�<�<�<�y�<�<�<�D'�'�'�'�'�.�'�'�'�>-�-�-�-�-�i�-�-�-�-�-r

Youez - 2016 - github.com/yon3zu
LinuXploit