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 ]

a

XC?h0`�@sZ
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�d�ZGdd�dee
e�ZGdd�dee�Zdd�Zdd�ZGdd�de
�ZGdd�de
�ZGdd�de�ZGdd�de�ZGdd �d e
�ZGd!d"�d"�ZGd#d$�d$ee
�ZGd%d&�d&ee�ZGd'd(�d(e
�ZdS))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�suppressc@s:eZ
dZd
Zee�
Zdd�Zej	dd��
Z
edd��
ZdS)	rz,An abstract base class for context managers.c


Cs|S�
z0Return `self` upon entering the runtime context.��
�selfrr�//opt/alt/python39/lib64/python3.9/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__szAbstractContextManager.__exit__cCs|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�abstractmethodrr%rrrrrs


rc@s:eZ
dZd
Zee�
Zdd�Zej	dd��
Z
edd��
ZdS)	rz9An abstract base class for asynchronous context managers.c


�s|Srrrrrr�
__aenter__+sz&AbstractAsyncContextManager.__aenter__c
�sd
Srrrrrr�	__aexit__/sz%AbstractAsyncContextManager.__aexit__cCs|turt
�|
d
d�StS)Nr.r/)rrr r!r"rrrr%4s


�z,AbstractAsyncContextManager.__subclasshook__N)r&r'r(r)r*rr+r.r,r-r/r%rrrrr%s


rc@s eZ
dZd
Zdd�Zdd�ZdS)rzJA base class or mixin that enables context managers to work as decorators.c


Cs|S)
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_cmcst��
��
fd
d��
}|S)Ncs:�
���
�|i|
�
�
Wd�
S1s,0


Y
dS�
N)
r0��args�kwds��funcrrr�innerLs

z(ContextDecorator.__call__.<locals>.innerr)rr6r7rr5r�__call__Ks

zContextDecorator.__call__N)r&r'r(r)r0r8rrrrr<s
rc@s eZ
dZd
Zdd�Zdd�ZdS)�_GeneratorContextManagerBasezBShared functionality for @contextmanager and @asynccontextmanager.cCsN|
|i|�
�
|_|
|||_
|_|_t|
d
d�}|durDt|�
j}||_dS)Nr))�genr6r3r4�getattr�typer))rr6r3r4�docrrr�__init__Vs





z%_GeneratorContextManagerBase.__init__c

Cs|�|j
|j|j�Sr1)�	__class__r6r3r4rrrrr0dsz)_GeneratorContextManagerBase._recreate_cmN)r&r'r(r)r>r0rrrrr9Ss
r9c@s eZ
dZd
Zdd�Zdd�ZdS)�_GeneratorContextManagerz%Helper for @contextmanager decorator.c

Cs:|`|`
|`zt|j�
WSty4


td
�
d�Yn0dS�Nzgenerator didn't yield)r3r4r6�nextr:�
StopIteration�RuntimeErrorrrrrrrs




z"_GeneratorContextManager.__enter__c
Cs 
|
dur6zt|j
�

Wnty*


Yd
S0td�
�
n�|durD|
�}z|j
�|
||�
Wn�ty�
}
z||u
WYd}~Sd}~0ty�
}
zF||ur�WYd}~d
St|t�r�|j|ur�WYd}~d
S�WYd}~n<d}~0t�
y
}
z||u
�r��WYd}~d
Sd}~00td�
�
dS)NF�generator didn't stopz#generator didn't stop after throw())rBr:rCrD�throw�
isinstance�	__cause__�
BaseException�r�typ�valuer�excrrrr{s4










��





z!_GeneratorContextManager.__exit__N)r&r'r(r)rrrrrrr@ks	r@c@s eZ
dZd
Zdd�Zdd�ZdS)�_AsyncGeneratorContextManagerz*Helper for @asynccontextmanager decorator.c

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


td
�
d�Yn0dSrA)r3r4r6r:�	__anext__�StopAsyncIterationrDrrrrr.�s




z(_AsyncGeneratorContextManager.__aenter__c
�s4
|
dur>z|j�
�IdH
Wnty0


Yd
S0td�
�
�n�|durL|
�}z|j�|
||�IdH
Wn�ty�
}
z||u
WYd}~Sd}~0t�y�
}
zJ||ur�WYd}~d
St|ttf�r�|j|ur�WYd}~d
S�WYd}~n<d}~0t�
y&
}
z||u
�
r�WYd}~d
Sd}~00td�
�
dS)NFrEz$generator didn't stop after athrow())	r:rOrPrD�athrowrGrCrHrIrJrrrr/�s4









��





z'_AsyncGeneratorContextManager.__aexit__N)r&r'r(r)r.r/rrrrrN�s	rNc
st��
�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>
    cst�||
�Sr1)
r@r2�
r6rr�helper
szcontextmanager.<locals>.helperr�r6rSrrRrr�s
rc
st��
�f
d
d��
}
|
S)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>
    cst�||
�Sr1)
rNr2rRrrrS&
sz#asynccontextmanager.<locals>.helperrrTrrRrr
s
rc@s(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()

    cCs
|
|_dSr1�
�thing)rrVrrrr>=
s
zclosing.__init__c


Cs|jSr1rUrrrrr?
s
zclosing.__enter__c
Gs|j�
�
dSr1)rV�close)r�exc_inforrrrA
s
zclosing.__exit__N�r&r'r(r)r>rrrrrrr	,
s
r	c@s(eZ
dZd
Zdd�Zdd�Zdd�Zd
S)�_RedirectStreamNcCs|
|_g|_
dSr1)�_new_target�_old_targets)r�
new_targetrrrr>I
s
z_RedirectStream.__init__c

Cs*|j�
tt|j��

tt|j|j�
|jSr1)r\�appendr;�sys�_stream�setattrr[rrrrrN
s


z_RedirectStream.__enter__cCstt
|j|j���
dSr1)rar_r`r\�pop�r�exctype�excinst�exctbrrrrS
s
z_RedirectStream.__exit__)r&r'r(r`r>rrrrrrrZE
srZc
@seZ
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`rrrrrW
s
rc
@seZ
dZd
ZdZdS)rzCContext manager for temporarily redirecting stderr to another file.�stderrNrhrrrrrg
s
rc@s(eZ
dZd
Zdd�Zdd�Zdd�ZdS)	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
Gs
|
|_dSr1)
�_exceptions)r�
exceptionsrrrr>x
s
zsuppress.__init__c


CsdSr1rrrrrr{
s
zsuppress.__enter__cCs|
du
ot|
|j
�Sr1)�
issubclassrjrcrrrr~
s
zsuppress.__exit__NrYrrrrrm
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.cCs
t|
|�Sr1�
r��cm�cm_exitrrr�_create_exit_wrapper�
sz#_BaseExitStack._create_exit_wrapperc

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

dSr1r�rrM�tb�r3�callbackr4rr�
_exit_wrapper�
s
z8_BaseExitStack._create_cb_wrapper.<locals>._exit_wrapperr�rvr3r4rwrrur�_create_cb_wrapper�
sz!_BaseExitStack._create_cb_wrapperc

Cst�|_
dSr1)r�_exit_callbacksrrrrr>�
s
z_BaseExitStack.__init__c
Cst|�
�}
|j
|
_
t�|_
|
S)
z@Preserve the context stack by transferring it to a new instance.)r<rzr)r�	new_stackrrr�pop_all�
s



z_BaseExitStack.pop_allcCs@t|
�
}z
|j
}Wnty.


|�|
�

Yn0|�|
|�
|
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).
        )r<r�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.
        )r<rrr�rrp�_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.
        )ry�__wrapped__r~�rrvr3r4rwrrrrv�
s


z_BaseExitStack.callbackcCs|�|
|�}|�
|d
�
dS)z;Helper to correctly register callbacks to __exit__ methods.TN)rrr~�rrprqrwrrrr�
s
z_BaseExitStack._push_cm_exitTcCs|j�
||
f�

dSr1)rzr^)rrv�is_syncrrrr~�
s
z"_BaseExitStack._push_exit_callbackN)
T)r&r'r(r)�staticmethodrrryr>r|r�r�rvrr~rrrrrm�
s





rmc@s(eZ
dZd
Zdd�Zdd�Zdd�ZdS)	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


Cs|Sr1rrrrrr�
s
zExitStack.__enter__c

s�|
d
du
}t�
�d��f
dd�}d}d}|jr�|j��\}}|sHJ�
z||
�r^d}d}d}
Wq,


t�
�}||d|
d�
d}|}
Yq,0q,|r�z|
dj}	|
d�
Wnty�


|	|
d_�Yn0|o�|S)Nr
�
cs4|j}|dus||
urdS|�ur$q*|}q|
|_dSr1�
�__context__��new_exc�old_exc�exc_context�
�	frame_excrr�_fix_exception_context�
s



z2ExitStack.__exit__.<locals>._fix_exception_contextFT�NNN�r_rXrzrbr�rI)
r�exc_details�received_excr��suppressed_exc�
pending_raiser��cb�new_exc_details�	fixed_ctxrr�rr�
s4























zExitStack.__exit__c

Cs|�d
d
d
�
d
S�z%Immediately unwind the context stack.N)
rrrrrrWszExitStack.closeN)r&r'r(r)rrrWrrrrr�
s

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.
    cCs
t|
|�Sr1rnrorrr�_create_async_exit_wrapper-sz)AsyncExitStack._create_async_exit_wrapperc

s��
�fd
d�}|S)Nc�s�
�i��
�
IdH
dSr1rrsrurrrw3s
z>AsyncExitStack._create_async_cb_wrapper.<locals>._exit_wrapperrrxrrur�_create_async_cb_wrapper1sz'AsyncExitStack._create_async_cb_wrapperc�s.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)r<r/r.�_push_async_cm_exitr�rrr�enter_async_context7s




z"AsyncExitStack.enter_async_contextcCsBt|
�
}z
|j
}Wnty0


|�|
d
�
Yn0|�|
|�
|
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)r<r/r}r~r�r�rrr�push_async_exitCs




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_callbackUs

z"AsyncExitStack.push_async_callbackc

�s|�d
d
d
�Id
H
d
Sr�)
r/rrrr�aclosebszAsyncExitStack.aclosecCs|�|
|�}|�
|d
�
dS)zLHelper to correctly register coroutine function to __aexit__
        method.FN)r�r~r�rrrr�fs
z"AsyncExitStack._push_async_cm_exitc


�s|Sr1rrrrrr.ls
zAsyncExitStack.__aenter__c
�s�|
d
du
}t�
�d��f
dd�}d}d}|jr�|j��\}}z0|rP||
�}n||
�IdH}|rnd}d}d}
Wq,


t�
�}	||	d|
d�
d}|	}
Yq,0q,|r�z|
dj}
|
d�
Wnty�


|
|
d_�Yn0|o�|S)Nr
r�cs4|j}|dus||
urdS|�ur$q*|}q|
|_dSr1r�r�r�rrr�us



z8AsyncExitStack.__aexit__.<locals>._fix_exception_contextFTr�r�)rr�r�r�r�r�r�r��cb_suppressr�r�rr�rr/os8
























zAsyncExitStack.__aexit__N)r&r'r(r)r�r�r�r�r�r�r�r�r.r/rrrrr
 s





r
c@s*eZ
dZd
Zd	dd�
Zdd�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
    NcCs
|
|_dSr1�
�enter_result)rr�rrrr>�s
znullcontext.__init__c


Cs|jSr1r�rrrrr�s
znullcontext.__enter__c

GsdSr1r)r�excinforrrr�s
znullcontext.__exit__)
NrYrrrrr
�s


r
)r)r,r_r�collectionsr�	functoolsr�typesrr�__all__�ABCrr�objectrr9r@rNrrr	rZrrrrmrr
r
rrrr�<module>
s>









�A
�>!!PE