Operation   : Linux premium131.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Software     : Apache
Server IP    : 162.0.232.56 | Your IP: 216.73.216.111
Domains      : 1034 Domain(s)
Permission   : [ 0755 ]

o

�=?he�@s~
dZd
dl
Z
d
dlZd
dlZd
dlmZ
d
dlmZ
d
dlm	Z	m
Z

gd�
ZGdd�de
j�Z
Gd	d
�d
e
j�ZGdd�de�ZGd
d�de�ZGdd�d�ZGdd�dee
e�ZGdd�deee�Zdd�Zdd�ZGdd�de
�ZGdd�de�ZGdd�de
�ZGdd �d e�ZGd!d"�d"e�ZGd#d$�d$e
�ZGd%d&�d&�ZGd'd(�d(ee
�ZGd)d*�d*ee�ZGd+d,�d,e
e�Z dS)-z4Utilities for with-statement contexts.  See PEP 343.�N)
�deque�
�wraps)�
MethodType�GenericAlias)
�asynccontextmanager�contextmanager�closing�nullcontext�AbstractContextManager�AbstractAsyncContextManager�AsyncExitStack�ContextDecorator�	ExitStack�redirect_stdout�redirect_stderr�suppress�aclosingc@�:eZ
dZd
Zee�
Zdd�Zej	dd��
Z
edd��
ZdS)	rz,An abstract base class for context managers.c


C�|S�
z0Return `self` upon entering the runtime context.��
�selfrr�1/opt/alt/python310/lib64/python3.10/contextlib.py�	__enter__sz AbstractContextManager.__enter__c
Csd
S�z9Raise any exception triggered within the runtime context.Nr�r�exc_type�	exc_value�	tracebackrrr�__exit__�zAbstractContextManager.__exit__cC�|turt
�|
d
d�StS)Nrr!)r�_collections_abc�_check_methods�NotImplemented��cls�
Crrr�__subclasshook__s

z'AbstractContextManager.__subclasshook__N)�__name__�
__module__�__qualname__�__doc__�classmethodr�__class_getitem__r�abc�abstractmethodr!r*rrrrr�


rc@r)	rz9An abstract base class for asynchronous context managers.c


���
|Srrrrrr�
__aenter__+s�z&AbstractAsyncContextManager.__aenter__c
�s�
d
Srrrrrr�	__aexit__/s�z%AbstractAsyncContextManager.__aexit__cCr#)Nr5r6)rr$r%r&r'rrrr*4s


�z,AbstractAsyncContextManager.__subclasshook__N)r+r,r-r.r/rr0r5r1r2r6r*rrrrr%r3rc@� eZ
dZd
Zdd�Zdd�ZdS)rzJA base class or mixin that enables context managers to work as decorators.c


Cr)
a6
Return a recreated instance of self.

        Allows an otherwise one-shot context manager like
        _GeneratorContextManager to support use as
        a decorator via implicit recreation.

        This is a private interface just for _GeneratorContextManager.
        See issue #11647 for details.
        rrrrr�_recreate_cm?s
zContextDecorator._recreate_cmc�t��
��
fd
d��
}|S)Ncs:�
���
�|i|
�
�
Wd�
S1sw



Y
dS�
N�
r8��args�kwds��funcrrr�innerLs

$�z(ContextDecorator.__call__.<locals>.innerr�rr@rArr?r�__call__K�

zContextDecorator.__call__N�r+r,r-r.r8rCrrrrr<s
rc@r7)�AsyncContextDecoratorzPA base class or mixin that enables async context managers to work as decorators.c


Cr)
z-Return a recreated instance of self.
        rrrrrr8Vr"z"AsyncContextDecorator._recreate_cmcr9)Nc	�sV�
�
��4IdH�
�|i|
�
�
IdHWd�IdH
S1IdHs$w



Y
dSr:r;r<r?rrrA\s�
0�z-AsyncContextDecorator.__call__.<locals>.innerrrBrr?rrC[rDzAsyncContextDecorator.__call__NrErrrrrFSs
rFc@r7)�_GeneratorContextManagerBasezBShared functionality for @contextmanager and @asynccontextmanager.cCsN|
|i|�
�
|_|
|||_
|_|_t|
d
d�}|dur"t|�
j}||_dS)Nr.)�genr@r=r>�getattr�typer.)rr@r=r>�docrrr�__init__fs






z%_GeneratorContextManagerBase.__init__c

Cs|�|j
|j|j�Sr:)�	__class__r@r=r>rrrrr8tsz)_GeneratorContextManagerBase._recreate_cmN)r+r,r-r.rLr8rrrrrGcs
rGc@r7)�_GeneratorContextManagerz%Helper for @contextmanager decorator.c

Cs2|`|`
|`zt|j�
WSty


td
�
d�w�Nzgenerator didn't yield)r=r>r@�nextrH�
StopIteration�RuntimeErrorrrrrr�s




�z"_GeneratorContextManager.__enter__c
Cs
|
durz
t|j
�

Wtd�
�
ty


Yd
Sw|dur |
�}z
|j
�|
||�
Wtd�
�
tyC
}
z
||u
WYd}~Sd}~w
tyk
}
z||urUWYd}~d
St|t�rf|j|urfWYd}~d
S�d}~w
ty�
}
z||u
rw�WYd}~d
Sd}~w
w)NF�generator didn't stopz#generator didn't stop after throw())rPrHrQrR�throw�
isinstance�	__cause__�
BaseException�r�typ�valuer �excrrrr!�s<


�
�

 ��

�

�


��z!_GeneratorContextManager.__exit__N)r+r,r-r.rr!rrrrrN{�	rNc@r7)�_AsyncGeneratorContextManagerz*Helper for @asynccontextmanager decorator.c

�s:�
|`|`
|`z	t|j�
IdHWSty


td
�
d�wrO)r=r>r@�anextrH�StopAsyncIterationrRrrrrr5�s�




�z(_AsyncGeneratorContextManager.__aenter__c
�s
�
|
durz
t|j
�
IdH
Wtd�
�
ty


Yd
Sw|dur$|
�}z|j
�|
||�IdH
Wtd�
�
tyJ
}
z
||u
WYd}~Sd}~w
tyt
}
z||ur\WYd}~d
St|ttf�ro|j|uroWYd}~d
S�d}~w
ty�
}
z||u
r��WYd}~d
Sd}~w
w)NFrSz$generator didn't stop after athrow())	r^rHr_rR�athrowrUrQrVrWrXrrrr6�s>�


�
�

 ��

�

�


��z'_AsyncGeneratorContextManager.__aexit__N)r+r,r-r.r5r6rrrrr]�r\r]c
�t��
�f
d
d��
}
|
S)a�
@contextmanager decorator.

    Typical usage:

        @contextmanager
        def some_generator(<arguments>):
            <setup>
            try:
                yield <value>
            finally:
                <cleanup>

    This makes this:

        with some_generator(<arguments>) as <variable>:
            <body>

    equivalent to this:

        <setup>
        try:
            <variable> = <value>
            <body>
        finally:
            <cleanup>
    c�t�||
�Sr:)
rNr<�
r@rr�helper
�zcontextmanager.<locals>.helperr�r@rdrrcrr��
rc
ra)a�
@asynccontextmanager decorator.

    Typical usage:

        @asynccontextmanager
        async def some_async_generator(<arguments>):
            <setup>
            try:
                yield <value>
            finally:
                <cleanup>

    This makes this:

        async with some_async_generator(<arguments>) as <variable>:
            <body>

    equivalent to this:

        <setup>
        try:
            <variable> = <value>
            <body>
        finally:
            <cleanup>
    crbr:)
r]r<rcrrrd8
rez#asynccontextmanager.<locals>.helperrrfrrcrr
rgrc@�(eZ
dZd
Zdd�Zdd�Zdd�ZdS)	r	a2
Context to automatically close something at the end of a block.

    Code like this:

        with closing(<module>.open(<arguments>)) as f:
            <block>

    is equivalent to this:

        f = <module>.open(<arguments>)
        try:
            <block>
        finally:
            f.close()

    cC�
|
|_dSr:�
�thing�rrkrrrrLO
�

zclosing.__init__c


C�|jSr:rjrrrrrQ
�
zclosing.__enter__c
Gs|j�
�
dSr:)rk�close�r�exc_inforrrr!S
s
zclosing.__exit__N�r+r,r-r.rLrr!rrrrr	>
s

r	c@rh)	ra�
Async context manager for safely finalizing an asynchronously cleaned-up
    resource such as an async generator, calling its ``aclose()`` method.

    Code like this:

        async with aclosing(<module>.fetch(<arguments>)) as agen:
            <block>

    is equivalent to this:

        agen = <module>.fetch(<arguments>)
        try:
            <block>
        finally:
            await agen.aclose()

    cCrir:rjrlrrrrLi
rmzaclosing.__init__c


���
|jSr:rjrrrrr5k
��
zaclosing.__aenter__c
�s�
|j�
�IdH
dSr:)rk�acloserqrrrr6m
s�
zaclosing.__aexit__N)r+r,r-r.rLr5r6rrrrrW
s

rc@s(eZ
dZd
Zdd�Zdd�Zdd�Zd
S)�_RedirectStreamNcCs|
|_g|_
dSr:)�_new_target�_old_targets)r�
new_targetrrrrLu
s

z_RedirectStream.__init__c

Cs*|j�
tt|j��

tt|j|j�
|jSr:)ry�appendrI�sys�_stream�setattrrxrrrrrz
s


z_RedirectStream.__enter__cCstt
|j|j���
dSr:)r~r|r}ry�pop�r�exctype�excinst�exctbrrrr!
s
z_RedirectStream.__exit__)r+r,r-r}rLrr!rrrrrwq
s
rwc
@�eZ
dZd
ZdZdS)raA
Context manager for temporarily redirecting stdout to another file.

        # How to send help() to stderr
        with redirect_stdout(sys.stderr):
            help(dir)

        # How to write help() to a file
        with open('help.txt', 'w') as f:
            with redirect_stdout(f):
                help(pow)
    �stdoutN�r+r,r-r.r}rrrrr�
s
rc
@r�)rzCContext manager for temporarily redirecting stderr to another file.�stderrNr�rrrrr�
s
rc@rh)	ra?
Context manager to suppress specified exceptions

    After the exception is suppressed, execution proceeds with the next
    statement following the with statement.

         with suppress(FileNotFoundError):
             os.remove(somefile)
         # Execution still resumes here if the file was already removed
    c
Grir:)
�_exceptions)r�
exceptionsrrrrL�
rmzsuppress.__init__c


C�dSr:rrrrrr�
�
zsuppress.__enter__cCs|
du
o	t|
|j
�Sr:)�
issubclassr�r�rrrr!�
s
zsuppress.__exit__Nrsrrrrr�
s


rc@sbeZ
dZd
Zedd��
Zedd��
Zdd�Zdd	�Zd
d�Z	dd
�Z
dd�Zdd�Zddd�
Z
dS)�_BaseExitStackz.A base class for ExitStack and AsyncExitStack.cC�
t|
|�Sr:�
r��cm�cm_exitrrr�_create_exit_wrapper�
�
z#_BaseExitStack._create_exit_wrapperc

���
�fd
d�}|S)Ncs�
�i��
�

dSr:r�rr[�tb�r=�callbackr>rr�
_exit_wrapper�
s
z8_BaseExitStack._create_cb_wrapper.<locals>._exit_wrapperr�r�r=r>r�rr�r�_create_cb_wrapper�
�z!_BaseExitStack._create_cb_wrapperc

Cst�|_
dSr:)r�_exit_callbacksrrrrrL�
s
z_BaseExitStack.__init__c
Cst|�
�}
|j
|
_
t�|_
|
S)
z@Preserve the context stack by transferring it to a new instance.)rJr�r)r�	new_stackrrr�pop_all�
s



z_BaseExitStack.pop_allcCsBt|
�
}z|j
}Wnty


|�|
�

Y|
Sw|�|
|�
|
S)
a
Registers a callback with the standard __exit__ method signature.

        Can suppress exceptions the same way __exit__ method can.
        Also accepts any object with an __exit__ method (registering a call
        to the method instead of the object itself).
        )rJr!�AttributeError�_push_exit_callback�
_push_cm_exit�r�exit�_cb_type�exit_methodrrr�push�
s	


�
z_BaseExitStack.pushcCs(t|
�
}|j
}|�|
�
}|�|
|�
|S)
z�Enters the supplied context manager.

        If successful, also pushes its __exit__ method as a callback and
        returns the result of the __enter__ method.
        )rJr!rr��rr��_cm_type�_exit�resultrrr�
enter_context�
s





z_BaseExitStack.enter_contextcOs,|j|
g
|�
Ri|�
�
}|
|_
|�|�

|
S)
z\Registers an arbitrary callback and arguments.

        Cannot suppress exceptions.
        )r��__wrapped__r��rr�r=r>r�rrrr��
s


z_BaseExitStack.callbackcC�|�|
|�}|�
|d
�
dS)z;Helper to correctly register callbacks to __exit__ methods.TN)r�r��rr�r�r�rrrr��
s
z_BaseExitStack._push_cm_exitTcCs|j�
||
f�

dSr:)r�r{)rr��is_syncrrrr�s
z"_BaseExitStack._push_exit_callbackN)
T)r+r,r-r.�staticmethodr�r�rLr�r�r�r�r�r�rrrrr��
s





r�c@rh)	ra�
Context manager for dynamic management of a stack of exit callbacks.

    For example:
        with ExitStack() as stack:
            files = [stack.enter_context(open(fname)) for fname in filenames]
            # All opened files will automatically be closed at the end of
            # the with statement, even if attempts to open files later
            # in the list raise an exception.
    c


Crr:rrrrrrr�zExitStack.__enter__c

s�|
d
du
}t�
�d��f
dd�}d}d}|jrI|j��\}}|s$J�
z||
�r/d}d}d}
Wn


t�
�}||d|
d�
d}|}
Y|js|rbz	|
dj}	|
d�
tya


|	|
d_�w|oe|S)Nr
�
c�6	|j}|dus||
urdS|�urn|}q
|
|_dSr:�
�__context__��new_exc�old_exc�exc_context�
�	frame_excrr�_fix_exception_context�




�

z2ExitStack.__exit__.<locals>._fix_exception_contextFT�NNN�r|rrr�rr�rW)
r�exc_details�received_excr��suppressed_exc�
pending_raiser��cb�new_exc_details�	fixed_ctxrr�rr!s:










�



�






�zExitStack.__exit__c

Cs|�d
d
d
�
d
S�z%Immediately unwind the context stack.N)
r!rrrrrpFszExitStack.closeN)r+r,r-r.rr!rprrrrrs


1rc@s`eZ
dZd
Zedd��
Zedd��
Zdd�Zdd	�Zd
d�Z	dd
�Z
dd�Zdd�Zdd�Z
dS)r
a�
Async context manager for dynamic management of a stack of exit
    callbacks.

    For example:
        async with AsyncExitStack() as stack:
            connections = [await stack.enter_async_context(get_connection())
                for i in range(5)]
            # All opened connections will automatically be released at the
            # end of the async with statement, even if attempts to open a
            # connection later in the list raise an exception.
    cCr�r:r�r�rrr�_create_async_exit_wrapperYr�z)AsyncExitStack._create_async_exit_wrapperc

r�)Nc�s�
�
�i��
�
IdH
dSr:rr�r�rrr�_s�
z>AsyncExitStack._create_async_cb_wrapper.<locals>._exit_wrapperrr�rr�r�_create_async_cb_wrapper]r�z'AsyncExitStack._create_async_cb_wrapperc�s0�
t|
�
}|j
}|�|
�
Id
H}|�|
|�
|S)z�Enters the supplied async context manager.

        If successful, also pushes its __aexit__ method as a callback and
        returns the result of the __aenter__ method.
        N)rJr6r5�_push_async_cm_exitr�rrr�enter_async_contextcs�



z"AsyncExitStack.enter_async_contextcCsDt|
�
}z|j
}Wnty


|�|
d
�
Y|
Sw|�|
|�
|
S)a#
Registers a coroutine function with the standard __aexit__ method
        signature.

        Can suppress exceptions the same way __aexit__ method can.
        Also accepts any object with an __aexit__ method (registering a call
        to the method instead of the object itself).
        F)rJr6r�r�r�r�rrr�push_async_exitos



�
zAsyncExitStack.push_async_exitcOs.|j|
g
|�
Ri|�
�
}|
|_
|�|d
�
|
S)zfRegisters an arbitrary coroutine function and arguments.

        Cannot suppress exceptions.
        F)r�r�r�r�rrr�push_async_callback�s

z"AsyncExitStack.push_async_callbackc

�s�
|�d
d
d
�Id
H
d
Sr�)
r6rrrrrv�s�zAsyncExitStack.aclosecCr�)zLHelper to correctly register coroutine function to __aexit__
        method.FN)r�r�r�rrrr��s
z"AsyncExitStack._push_async_cm_exitc


�r4r:rrrrrr5���
zAsyncExitStack.__aenter__c
�s��
|
d
du
}t�
�d��f
dd�}d}d}|jrR|j��\}}z|r)||
�}n||
�IdH}|r8d}d}d}
Wn


t�
�}	||	d|
d�
d}|	}
Y|js|rkz	|
dj}
|
d�
tyj


|
|
d_�w|on|S)Nr
r�cr�r:r�r�r�rrr��r�z8AsyncExitStack.__aexit__.<locals>._fix_exception_contextFTr�r�)rr�r�r�r�r�r�r��cb_suppressr�r�rr�rr6�s@�











�



�






�zAsyncExitStack.__aexit__N)r+r,r-r.r�r�r�r�r�r�rvr�r5r6rrrrr
Ls





r
c@s:eZ
dZd
Zd
dd�
Zdd�Zdd�Zd	d
�Zdd�ZdS)r
aO
Context manager that does no additional processing.

    Used as a stand-in for a normal context manager, when a particular
    block of code is only sometimes used with a normal context manager:

    cm = optional_cm if condition else nullcontext()
    with cm:
        # Perform operation, using optional_cm if condition is True
    NcCrir:�
�enter_result)rr�rrrrL�rmznullcontext.__init__c


Crnr:r�rrrrr�roznullcontext.__enter__c

Gr�r:r�r�excinforrrr!�r�znullcontext.__exit__c


�rtr:r�rrrrr5�ruznullcontext.__aenter__c

�s�
dSr:rr�rrrr6�r�znullcontext.__aexit__r:)	r+r,r-r.rLrr!r5r6rrrrr
�s


r
)!r.r1r|r$�collectionsr�	functoolsr�typesrr�__all__�ABCrr�objectrrFrGrNr]rrr	rrwrrrr�rr
r
rrrr�<module>
sH









�
@


�A!!PE