GRAYBYTE WORDPRESS FILE MANAGER8449

U

e5d�a�@sj
dZd
dl
Z
d
dlZd
dlZd
dlmZ
d
dlmZ
d
dlm	Z	
dddd	d
ddd
ddddgZ
Gdd
�d
e
j�ZGdd�de
j�Z
Gdd
�d
e�ZGdd�d�ZGdd�deee�ZGdd�dee
�Zdd�Zdd�ZGdd�de�ZGdd�de�ZGd d�de�ZGd!d�de�ZGd"d�de�ZGd#d$�d$�ZGd%d�dee�ZGd&d�dee
�ZGd'd	�d	e�ZdS)(z4Utilities for with-statement contexts.  See PEP 343.�N)
�deque�
�wraps�
�
MethodType�asynccontextmanager�contextmanager�closing�nullcontext�AbstractContextManager�AbstractAsyncContextManager�AsyncExitStack�ContextDecorator�	ExitStack�redirect_stdout�redirect_stderr�suppressc@s2eZ
dZd
Zdd�Zejdd��
Zedd��
Z	dS)	rz,An abstract base class for context managers.c


Cs|S�
z0Return `self` upon entering the runtime context.��
�selfrr�"/usr/lib64/python3.8/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|tkrt
�|
d
d�StS)Nrr)r�_collections_abc�_check_methods�NotImplemented��cls�
Crrr�__subclasshook__s

z'AbstractContextManager.__subclasshook__N)
�__name__�
__module__�__qualname__�__doc__r�abc�abstractmethodr�classmethodr%rrrrrs


c@s2eZ
dZd
Zdd�Zejdd��
Zedd��
Z	dS)	rz9An abstract base class for asynchronous context managers.c


�s|Srrrrrr�
__aenter__'sz&AbstractAsyncContextManager.__aenter__c
�sd
Srrrrrr�	__aexit__+sz%AbstractAsyncContextManager.__aexit__cCs|tkrt
�|
d
d�StS)Nr-r.)rrr r!r"rrrr%0s


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


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)Nc
s*�
���
�||
�
W5QR�SQRXdS�
N)
r/��args�kwds��funcrrr�innerHs

z(ContextDecorator.__call__.<locals>.innerr)rr5r6rr4r�__call__Gs

zContextDecorator.__call__N)r&r'r(r)r/r7rrrrr8s
c@seZ
dZd
Zdd�ZdS)�_GeneratorContextManagerBasezBShared functionality for @contextmanager and @asynccontextmanager.cCsJ|
||�
|_|
|||_
|_|_t|
d
d�}|dkr@t|�
j}||_dS)Nr))�genr5r2r3�getattr�typer))rr5r2r3�docrrr�__init__Rs





z%_GeneratorContextManagerBase.__init__N)r&r'r(r)r=rrrrr8Os
r8c@s(eZ
dZd
Zdd�Zdd�Zdd�ZdS)	�_GeneratorContextManagerz%Helper for @contextmanager decorator.c

Cs|�|j
|j|j�Sr0)�	__class__r5r2r3rrrrr/fsz%_GeneratorContextManager._recreate_cmc

Cs<|`|`
|`zt|j�
WStk
r6


td
�
d�YnXdS�Nzgenerator didn't yield)r2r3r5�nextr9�
StopIteration�RuntimeErrorrrrrrls




z"_GeneratorContextManager.__enter__c
Cs
|
dkr8zt|j
�

Wntk
r,


Yd
SXtd�
�
n�|dkrF|
�}z|j
�|
||�
Wn�tk
r�
}
z||k	WY�Sd}~XYnttk
r�
}
z4||kr�WY�&d
S|
tkr�|j|kr�WY�
d
S�W5d}~XYn$


t��d|kr�Yd
S�YnXtd�
�
dS)NF�generator didn't stop�
z#generator didn't stop after throw())rAr9rBrC�throw�	__cause__�sys�exc_info)rr;�valuer�excrrrrus.


















z!_GeneratorContextManager.__exit__N)r&r'r(r)r/rrrrrrr>as	r>c@s eZ
dZd
Zdd�Zdd�ZdS)�_AsyncGeneratorContextManagerz Helper for @asynccontextmanager.c

�s6z|j�
�IdHWStk
r0


td
�
d�YnXdSr@)r9�	__anext__�StopAsyncIterationrCrrrrr-�s



z(_AsyncGeneratorContextManager.__aenter__c
�s&
|
dkr>z|j�
�IdH
Wntk
r2


YdSXtd
�
�
n�|dkrL|
�}z"|j�|
||�IdH
td�
�
Wn�tk
r�
}
z||k	WY�Sd}~XYn�tk
r�
}
z:||kr�WY�,dSt|ttf�r�|j|kr�WY�
dS�W5d}~XYn0tk
�
r 
}
z||k	�
r�W5d}~XYnXdS)NrDz$generator didn't stop after athrow()F)	r9rMrNrC�athrow�
isinstancerBrG�
BaseException)r�typrJrrKrrrr.�s.























z'_AsyncGeneratorContextManager.__aexit__N)r&r'r(r)r-r.rrrrrL�srLc
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�||
�Sr0)
r>r1�
r5rr�helper�szcontextmanager.<locals>.helperr�r5rTrrSrr�s
c
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�||
�Sr0)
rLr1rSrrrT
sz#asynccontextmanager.<locals>.helperrrUrrSrr�s
c@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
|
|_dSr0�
�thing)rrWrrrr=&
s
zclosing.__init__c


Cs|jSr0rVrrrrr(
s
zclosing.__enter__c
Gs|j�
�
dSr0)rW�close)rrIrrrr*
s
zclosing.__exit__N�r&r'r(r)r=rrrrrrr	
s
c@s(eZ
dZd
Zdd�Zdd�Zdd�Zd
S)�_RedirectStreamNcCs|
|_g|_
dSr0)�_new_target�_old_targets)r�
new_targetrrrr=2
s
z_RedirectStream.__init__c

Cs*|j�
tt|j��

tt|j|j�
|jSr0)r\�appendr:rH�_stream�setattrr[rrrrr7
s


z_RedirectStream.__enter__cCstt
|j|j���
dSr0)r`rHr_r\�pop�r�exctype�excinst�exctbrrrr<
s
z_RedirectStream.__exit__)r&r'r(r_r=rrrrrrrZ.
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_rrrrr@
s
c
@seZ
dZd
ZdZdS)rzCContext manager for temporarily redirecting stderr to another file.�stderrNrgrrrrrP
s
c@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
|
|_dSr0)
�_exceptions)r�
exceptionsrrrr=a
s
zsuppress.__init__c


CsdSr0rrrrrrd
s
zsuppress.__enter__cCs|
dk	ot|
|j
�Sr0)�
issubclassrirbrrrrg
s
zsuppress.__exit__NrYrrrrrV
s

c@sheZ
dZd
Zedd��
Zedd��
Zdd�Zdd	�Zd
d�Z	dd
�Z
dd�Zde_dd�Z
ddd�
ZdS)�_BaseExitStackz.A base class for ExitStack and AsyncExitStack.cCs
t|
|�Sr0r��cm�cm_exitrrr�_create_exit_wrapperw
sz#_BaseExitStack._create_exit_wrapperc

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

dSr0r�rrK�tb�r2�callbackr3rr�
_exit_wrapper}
s
z8_BaseExitStack._create_cb_wrapper.<locals>._exit_wrapperr�rtr2r3rurrsr�_create_cb_wrapper{
sz!_BaseExitStack._create_cb_wrapperc

Cst�|_
dSr0)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;rxr)r�	new_stackrrr�pop_all�
s



z_BaseExitStack.pop_allcCsBt|
�
}z
|j
}Wntk
r0


|�|
�

YnX|�|
|�
|
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}�rrn�_cm_type�_exit�resultrrr�
enter_context�
s





z_BaseExitStack.enter_contextcOs�t|�
d
kr|^}}}nV|s&t
d�
�
nHd|
krZ|
�d�
}|^
}}ddl}|jdtd
d�
nt
dt|�
d	�
�
|j|f
|�|
�
}||_|�|�

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

        Cannot suppress exceptions.
        �zBdescriptor 'callback' of '_BaseExitStack' object needs an argumentrtr
N�4Passing 'callback' as keyword argument is deprecated�
�
stacklevelz8callback expected at least 1 positional argument, got %drE)	�len�	TypeErrorra�warnings�warn�DeprecationWarningrw�__wrapped__r|�r2r3rrtr�rurrrrt�
s&









�

�


z_BaseExitStack.callback�#($self, callback, /, *args, **kwds)cCs|�|
|�}|�
|d
�
dS)z;Helper to correctly register callbacks to __exit__ methods.TN)rpr|�rrnrorurrrr}�
s
z_BaseExitStack._push_cm_exitTcCs|j�
||
f�

dSr0)rxr^)rrt�is_syncrrrr|�
s
z"_BaseExitStack._push_exit_callbackN)
T)r&r'r(r)�staticmethodrprwr=rzr�r�rt�__text_signature__r}r|rrrrrlt
s




rlc@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|Sr0rrrrrr�
s
zExitStack.__enter__c

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


t�
�}||d|
d�
d}|}
Yq,Xq,|r�z|
dj}	|
d�
Wn tk
r�


|	|
d_�YnX|o�|S)Nr
rEcs4|j}||
krdS|dks*|�kr$q*|}q|
|_dSr0�
�__context__��new_exc�old_exc�exc_context�
�	frame_excrr�_fix_exception_context�
s



z2ExitStack.__exit__.<locals>._fix_exception_contextFT�NNN)rHrIrxra�AssertionErrorr�rQ)
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)
rrrrrrXszExitStack.closeN)r&r'r(r)rrrXrrrrr�
s

1c@sfeZ
dZd
Zedd��
Zedd��
Zdd�Zdd	�Zd
d�Z	de	_
d
d�Zdd�Zdd�Z
dd�ZdS)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|
|�Sr0rrmrrr�_create_async_exit_wrapper&sz)AsyncExitStack._create_async_exit_wrapperc

s��
�fd
d�}|S)Nc�s�
���
IdH
dSr0rrqrsrrru,s
z>AsyncExitStack._create_async_cb_wrapper.<locals>._exit_wrapperrrvrrsr�_create_async_cb_wrapper*sz'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_context0s




z"AsyncExitStack.enter_async_contextcCsDt|
�
}z
|j
}Wn tk
r2


|�|
d
�
YnX|�|
|�
|
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_exit<s




zAsyncExitStack.push_async_exitcOs�t|�
d
kr|^}}}nV|s&t
d�
�
nHd|
krZ|
�d�
}|^
}}ddl}|jdtd
d�
nt
dt|�
d	�
�
|j|f
|�|
�
}||_|�|d
�
|S)zfRegisters an arbitrary coroutine function and arguments.

        Cannot suppress exceptions.
        r�zMdescriptor 'push_async_callback' of 'AsyncExitStack' object needs an argumentrtr
Nr�r�zCpush_async_callback expected at least 1 positional argument, got %drEF)	r�r�rar�r�r�r�r�r|r�rrr�push_async_callbackNs&









�

�

z"AsyncExitStack.push_async_callbackr�c

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


�s|Sr0rrrrrr-us
zAsyncExitStack.__aenter__c
�s�|
d
dk	}t�
�d��f
dd�}d}d}|jr�|j��\}}z0|rP||
�}n||
�IdH}|rnd}d}d}
Wq,


t�
�}	||	d|
d�
d}|	}
Yq,Xq,|r�z|
dj}
|
d�
Wn tk
r�


|
|
d_�YnX|o�|S)Nr
rEcs4|j}||
krdS|dks*|�kr$q*|}q|
|_dSr0r�r�r�rrr�~s



z8AsyncExitStack.__aexit__.<locals>._fix_exception_contextFTr�)rHrIrxrar�rQ)rr�r�r�r�r�r�r��cb_suppressr�r�rr�rr.xs8
























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



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
|
|_dSr0�
�enter_result)rr�rrrr=�s
znullcontext.__init__c


Cs|jSr0r�rrrrr�s
znullcontext.__enter__c

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


)r)r*rHr�collectionsr�	functoolsr�typesr�__all__�ABCrr�objectrr8r>rLrrr	rZrrrrlrr
r
rrrr�<module>
sN








�

�D
�.!!`E