HEX

File: //lib/python3.10/__pycache__/contextlib.cpython-310.pyc
o

E�he�@s~dZddlZddlZddlZddlmZddlmZddlm	Z	m
Z
gd�ZGdd�dej�Z
Gd	d
�d
ej�ZGdd�de�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@�:eZdZdZee�Zdd�Zej	dd��Z
edd��ZdS)	rz,An abstract base class for context managers.cC�|S�z0Return `self` upon entering the runtime context.���selfrr�!/usr/lib/python3.10/contextlib.py�	__enter__sz AbstractContextManager.__enter__cCsdS�z9Raise any exception triggered within the runtime context.Nr�r�exc_type�	exc_value�	tracebackrrr�__exit__�zAbstractContextManager.__exit__cC�|turt�|dd�StS)Nrr!)r�_collections_abc�_check_methods�NotImplemented��cls�Crrr�__subclasshook__sz'AbstractContextManager.__subclasshook__N)�__name__�
__module__�__qualname__�__doc__�classmethodr�__class_getitem__r�abc�abstractmethodr!r*rrrrr�
rc@r)	rz9An abstract base class for asynchronous context managers.c���|Srrrrrr�
__aenter__+s�z&AbstractAsyncContextManager.__aenter__c�s�dSrrrrrr�	__aexit__/s�z%AbstractAsyncContextManager.__aexit__cCr#)Nr5r6)rr$r%r&r'rrrr*4s
�z,AbstractAsyncContextManager.__subclasshook__N)r+r,r-r.r/rr0r5r1r2r6r*rrrrr%r3rc@� eZdZdZdd�Zdd�ZdS)rzJA base class or mixin that enables context managers to work as decorators.cCr)a6Return 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����fdd��}|S)Ncs:�����|i|��Wd�S1swYdS�N�r8��args�kwds��funcrrr�innerLs
$�z(ContextDecorator.__call__.<locals>.innerr�rr@rArr?r�__call__K�zContextDecorator.__call__N�r+r,r-r.r8rCrrrrr<src@r7)�AsyncContextDecoratorzPA base class or mixin that enables async context managers to work as decorators.cCr)z-Return a recreated instance of self.
        rrrrrr8Vr"z"AsyncContextDecorator._recreate_cmcr9)Nc	�sV����4IdH��|i|��IdHWd�IdHS1IdHs$wYdSr:r;r<r?rrrA\s�0�z-AsyncContextDecorator.__call__.<locals>.innerrrBrr?rrC[rDzAsyncContextDecorator.__call__NrErrrrrFSsrFc@r7)�_GeneratorContextManagerBasezBShared functionality for @contextmanager and @asynccontextmanager.cCsN||i|��|_||||_|_|_t|dd�}|dur"t|�j}||_dS)Nr.)�genr@r=r>�getattr�typer.)rr@r=r>�docrrr�__init__fs

z%_GeneratorContextManagerBase.__init__cCs|�|j|j|j�Sr:)�	__class__r@r=r>rrrrr8tsz)_GeneratorContextManagerBase._recreate_cmN)r+r,r-r.rLr8rrrrrGcsrGc@r7)�_GeneratorContextManagerz%Helper for @contextmanager decorator.cCs2|`|`|`zt|j�WStytd�d�w�Nzgenerator didn't yield)r=r>r@�nextrH�
StopIteration�RuntimeErrorrrrrr�s
�z"_GeneratorContextManager.__enter__c
Cs|durz
t|j�Wtd��tyYdSw|dur |�}z
|j�|||�Wtd��tyC}z
||uWYd}~Sd}~wtyk}z||urUWYd}~dSt|t�rf|j|urfWYd}~dS�d}~wty�}z||urw�WYd}~dSd}~ww)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�IdHWStytd�d�wrO)r=r>r@�anextrH�StopAsyncIterationrRrrrrr5�s�
�z(_AsyncGeneratorContextManager.__aenter__c
�s�|durz
t|j�IdHWtd��tyYdSw|dur$|�}z|j�|||�IdHWtd��tyJ}z
||uWYd}~Sd}~wtyt}z||ur\WYd}~dSt|ttf�ro|j|uroWYd}~dS�d}~wty�}z||ur��WYd}~dSd}~ww)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���fdd��}|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��rcra)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<rcrrrd8rez#asynccontextmanager.<locals>.helperrrfrrcrrrgrc@�(eZdZdZdd�Zdd�Zdd�ZdS)	r	a2Context 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__cC�|jSr:rjrrrrrQ�zclosing.__enter__cGs|j��dSr:)rk�close�r�exc_inforrrr!Sszclosing.__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:rjrlrrrrLirmzaclosing.__init__c���|jSr:rjrrrrr5k��zaclosing.__aenter__c�s�|j��IdHdSr:)rk�acloserqrrrr6ms�zaclosing.__aexit__N)r+r,r-r.rLr5r6rrrrrWs
rc@s(eZdZdZdd�Zdd�Zdd�ZdS)�_RedirectStreamNcCs||_g|_dSr:)�_new_target�_old_targets)r�
new_targetrrrrLus
z_RedirectStream.__init__cCs*|j�tt|j��tt|j|j�|jSr:)ry�appendrI�sys�_stream�setattrrxrrrrrzsz_RedirectStream.__enter__cCstt|j|j���dSr:)r~r|r}ry�pop�r�exctype�excinst�exctbrrrr!sz_RedirectStream.__exit__)r+r,r-r}rLrr!rrrrrwqs
rwc@�eZdZdZdZdS)raAContext 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�src@r�)rzCContext manager for temporarily redirecting stderr to another file.�stderrNr�rrrrr�src@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
    cGrir:)�_exceptions)r�
exceptionsrrrrL�rmzsuppress.__init__cC�dSr:rrrrrr��zsuppress.__enter__cCs|duo	t||j�Sr:)�
issubclassr�r�rrrr!�s
zsuppress.__exit__Nrsrrrrr�s

rc@sbeZdZdZedd��Zedd��Zdd�Zdd	�Zd
d�Z	dd
�Z
dd�Zdd�Zddd�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����fdd�}|S)Ncs��i���dSr:r�rr[�tb�r=�callbackr>rr�
_exit_wrapper�sz8_BaseExitStack._create_cb_wrapper.<locals>._exit_wrapperr�r�r=r>r�rr�r�_create_cb_wrapper��z!_BaseExitStack._create_cb_wrappercCst�|_dSr:)r�_exit_callbacksrrrrrL�sz_BaseExitStack.__init__cCst|��}|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)aRegisters 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��sz_BaseExitStack._push_cm_exitTcCs|j�||f�dSr:)r�r{)rr��is_syncrrrr�sz"_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.
    cCrr:rrrrrrr�zExitStack.__enter__c
s�|ddu}t��d��fdd�}d}d}|jrI|j��\}}|s$J�z||�r/d}d}d}Wnt��}||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__cCs|�ddd�dS�z%Immediately unwind the context stack.N)r!rrrrrpFszExitStack.closeN)r+r,r-r.rr!rprrrrrs

1rc@s`eZdZdZedd��Zedd��Zdd�Zdd	�Zd
d�Z	dd
�Z
dd�Zdd�Zdd�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_wrappercr�)Nc�s���i���IdHdSr: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}|�|�IdH}|�||�|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�sz"AsyncExitStack.push_async_callbackc�s�|�ddd�IdHdSr�)r6rrrrrv�s�zAsyncExitStack.aclosecCr�)zLHelper to correctly register coroutine function to __aexit__
        method.FN)r�r�r�rrrr��sz"AsyncExitStack._push_async_cm_exitc�r4r:rrrrrr5���zAsyncExitStack.__aenter__c�s��|ddu}t��d��fdd�}d}d}|jrR|j��\}}z|r)||�}n||�IdH}|r8d}d}d}Wnt��}	||	d|d�d}|	}Y|js|rkz	|dj}
|d�tyj|
|d_�w|on|S)Nrr�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:eZdZdZd
dd�Zdd�Zdd�Zd	d
�Zdd�ZdS)r
aOContext 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__cCrnr:r�rrrrr�roznullcontext.__enter__cGr�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