o Tje@s~dZddlZddlZddlZddlmZddlmZddlm Z m Z gdZ Gdddej Z Gd d d ej ZGd d d eZGd ddeZGdddZGdddee eZGdddeeeZddZddZGddde ZGdddeZGddde ZGdd d eZGd!d"d"eZGd#d$d$e ZGd%d&d&ZGd'd(d(ee ZGd)d*d*eeZGd+d,d,e eZ dS)-z4Utilities for with-statement contexts. See PEP 343.N)dequewraps) MethodType GenericAlias) asynccontextmanagercontextmanagerclosing nullcontextAbstractContextManagerAbstractAsyncContextManagerAsyncExitStackContextDecorator ExitStackredirect_stdoutredirect_stderrsuppressaclosingc@:eZdZdZeeZddZej ddZ eddZ dS) r z,An abstract base class for context managers.cC|Sz0Return `self` upon entering the runtime context.selfrr!/usr/lib/python3.10/contextlib.py __enter__sz AbstractContextManager.__enter__cCsdSz9Raise any exception triggered within the runtime context.Nrrexc_type exc_value tracebackrrr__exit__zAbstractContextManager.__exit__cC|tur t|ddStS)Nrr!)r _collections_abc_check_methodsNotImplementedclsCrrr__subclasshook__sz'AbstractContextManager.__subclasshook__N) __name__ __module__ __qualname____doc__ classmethodr__class_getitem__rabcabstractmethodr!r*rrrrr  r c@r) r z9An abstract base class for asynchronous context managers.c|Srrrrrr __aenter__+sz&AbstractAsyncContextManager.__aenter__csdSrrrrrr __aexit__/sz%AbstractAsyncContextManager.__aexit__cCr#)Nr5r6)r r$r%r&r'rrrr*4s z,AbstractAsyncContextManager.__subclasshook__N) r+r,r-r.r/rr0r5r1r2r6r*rrrrr %r3r c@ eZdZdZddZddZdS)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_cmctfdd}|S)Ncs:|i|WdS1swYdSNr8argskwdsfuncrrrinnerLs  $z(ContextDecorator.__call__..innerrrr@rArr?r__call__KzContextDecorator.__call__Nr+r,r-r.r8rCrrrrr<s rc@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 sV4IdH|i|IdHWdIdHS1IdHs$wYdSr:r;r<r?rrrA\s0z-AsyncContextDecorator.__call__..innerrrBrr?rrC[rDzAsyncContextDecorator.__call__NrErrrrrFSs rFc@r7)_GeneratorContextManagerBasezBShared functionality for @contextmanager and @asynccontextmanager.cCsN||i||_||||_|_|_t|dd}|dur"t|j}||_dS)Nr.)genr@r=r>getattrtyper.)rr@r=r>docrrr__init__fs    z%_GeneratorContextManagerBase.__init__cCs||j|j|jSr:) __class__r@r=r>rrrrr8tsz)_GeneratorContextManagerBase._recreate_cmN)r+r,r-r.rLr8rrrrrGcs rGc@r7)_GeneratorContextManagerz%Helper for @contextmanager decorator.cCs2|`|`|`zt|jWStytddwNzgenerator didn't yield)r=r>r@nextrH StopIteration RuntimeErrorrrrrrs    z"_GeneratorContextManager.__enter__c Cs|durz t|jWtdtyYdSw|dur |}z |j|||WtdtyC}z ||uWYd}~Sd}~wtyk}z||urUWYd}~dSt|trf|j|urfWYd}~dSd}~wty}z ||urwWYd}~dSd}~ww)NFgenerator didn't stopz#generator didn't stop after throw())rPrHrQrRthrow isinstance __cause__ BaseExceptionrtypvaluer excrrrr!s<    z!_GeneratorContextManager.__exit__N)r+r,r-r.rr!rrrrrN{ rNc@r7)_AsyncGeneratorContextManagerz*Helper for @asynccontextmanager decorator.cs:|`|`|`z t|jIdHWStytddwrO)r=r>r@anextrHStopAsyncIterationrRrrrrr5s   z(_AsyncGeneratorContextManager.__aenter__c s|durz t|jIdHWtdtyYdSw|dur$|}z|j|||IdHWtdtyJ}z ||uWYd}~Sd}~wtyt}z||ur\WYd}~dSt|ttfro|j|uroWYd}~dSd}~wty}z ||urWYd}~dSd}~ww)NFrSz$generator didn't stop after athrow()) r^rHr_rRathrowrUrQrVrWrXrrrr6s>    z'_AsyncGeneratorContextManager.__aexit__N)r+r,r-r.r5r6rrrrr]r\r]ctfdd}|S)a@contextmanager decorator. Typical usage: @contextmanager def some_generator(): try: yield finally: This makes this: with some_generator() as : equivalent to this: try: = finally: c t||Sr:)rNr<r@rrhelper zcontextmanager..helperrr@rdrrcrrrcra)a@asynccontextmanager decorator. Typical usage: @asynccontextmanager async def some_async_generator(): try: yield finally: This makes this: async with some_async_generator() as : equivalent to this: try: = finally: crbr:)r]r<rcrrrd8rez#asynccontextmanager..helperrrfrrcrrrgrc@(eZdZdZddZddZddZdS) r a2Context to automatically close something at the end of a block. Code like this: with closing(.open()) as f: is equivalent to this: f = .open() try: finally: f.close() cC ||_dSr:thingrrkrrrrLO zclosing.__init__cC|jSr:rjrrrrrQzclosing.__enter__cGs|jdSr:)rkcloserexc_inforrrr!Sszclosing.__exit__Nr+r,r-r.rLrr!rrrrr >s  r c@rh) raAsync 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(.fetch()) as agen: is equivalent to this: agen = .fetch() try: finally: await agen.aclose() cCrir:rjrlrrrrLirmzaclosing.__init__c|jSr:rjrrrrr5kzaclosing.__aenter__cs|jIdHdSr:)rkacloserqrrrr6mszaclosing.__aexit__N)r+r,r-r.rLr5r6rrrrrWs  rc@s(eZdZdZddZddZddZdS)_RedirectStreamNcCs||_g|_dSr:) _new_target _old_targets)r new_targetrrrrLus z_RedirectStream.__init__cCs*|jtt|jtt|j|j|jSr:)ryappendrIsys_streamsetattrrxrrrrrzsz_RedirectStream.__enter__cCstt|j|jdSr:)r~r|r}rypoprexctypeexcinstexctbrrrr!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) stdoutNr+r,r-r.r}rrrrrs rc@r)rzCContext manager for temporarily redirecting stderr to another file.stderrNrrrrrrsrc@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 exceptionsrrrrLrmzsuppress.__init__cCdSr:rrrrrrzsuppress.__enter__cCs|duo t||jSr:) issubclassrrrrrr!s zsuppress.__exit__Nrsrrrrrs   rc@sbeZdZdZeddZeddZddZdd Zd d Z d d Z ddZ ddZ dddZ dS)_BaseExitStackz.A base class for ExitStack and AsyncExitStack.cC t||Sr:rcmcm_exitrrr_create_exit_wrapper z#_BaseExitStack._create_exit_wrappercfdd}|S)NcsidSr:rrr[tbr=callbackr>rr _exit_wrappersz8_BaseExitStack._create_cb_wrapper.._exit_wrapperrrr=r>rrrr_create_cb_wrapperz!_BaseExitStack._create_cb_wrappercCs t|_dSr:)r_exit_callbacksrrrrrLs z_BaseExitStack.__init__cCst|}|j|_t|_|S)z@Preserve the context stack by transferring it to a new instance.)rJrr)r new_stackrrrpop_alls 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_exitrexit_cb_type exit_methodrrrpushs     z_BaseExitStack.pushcCs(t|}|j}||}||||S)zEnters the supplied context manager. If successful, also pushes its __exit__ method as a callback and returns the result of the __enter__ method. )rJr!rrrr_cm_type_exitresultrrr enter_contexts   z_BaseExitStack.enter_contextcOs,|j|g|Ri|}||_|||S)z\Registers an arbitrary callback and arguments. Cannot suppress exceptions. )r __wrapped__rrrr=r>rrrrrs z_BaseExitStack.callbackcC|||}||ddS)z;Helper to correctly register callbacks to __exit__ methods.TN)rrrrrrrrrrs z_BaseExitStack._push_cm_exitTcCs|j||fdSr:)rr{)rris_syncrrrrsz"_BaseExitStack._push_exit_callbackN)T)r+r,r-r. staticmethodrrrLrrrrrrrrrrrs   rc@rh) raContext 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:rrrrrrrzExitStack.__enter__c s|ddu}tdfdd}d}d}|jrI|j\}}|s$Jz ||r/d}d}d}Wnt}||d|dd}|}Y|js|rbz |dj} |dtya| |d_w|oe|S)Nrc6 |j}|dus ||urdS|urn|}q||_dSr: __context__new_excold_exc exc_context frame_excrr_fix_exception_context z2ExitStack.__exit__.._fix_exception_contextFTNNNr|rrrrrrW) r exc_details received_excrsuppressed_exc pending_raisercbnew_exc_details fixed_ctxrrrr!s:      zExitStack.__exit__cCs|ddddSz%Immediately unwind the context stack.N)r!rrrrrpFszExitStack.closeN)r+r,r-r.rr!rprrrrrs   1rc@s`eZdZdZeddZeddZddZdd Zd d Z d d Z ddZ ddZ ddZ dS)r aAsync 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. cCrr:rrrrr_create_async_exit_wrapperYrz)AsyncExitStack._create_async_exit_wrappercr)NcsiIdHdSr:rrrrrr_sz>AsyncExitStack._create_async_cb_wrapper.._exit_wrapperrrrrr_create_async_cb_wrapper]rz'AsyncExitStack._create_async_cb_wrappercs0t|}|j}||IdH}||||S)zEnters 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_exitrrrrenter_async_contextcs  z"AsyncExitStack.enter_async_contextcCsDt|}z|j}Wnty||dY|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)rJr6rrrrrrrpush_async_exitos   zAsyncExitStack.push_async_exitcOs.|j|g|Ri|}||_||d|S)zfRegisters an arbitrary coroutine function and arguments. Cannot suppress exceptions. F)rrrrrrrpush_async_callbacks z"AsyncExitStack.push_async_callbackcs|dddIdHdSr)r6rrrrrvszAsyncExitStack.aclosecCr)zLHelper to correctly register coroutine function to __aexit__ method.FN)rrrrrrrs z"AsyncExitStack._push_async_cm_exitcr4r:rrrrrr5zAsyncExitStack.__aenter__c s|ddu}tdfdd}d}d}|jrR|j\}}z|r)||}n||IdH}|r8d}d}d}Wnt} || d|dd}| }Y|js|rkz |dj} |dtyj| |d_w|on|S)Nrrcrr:rrrrrrrz8AsyncExitStack.__aexit__.._fix_exception_contextFTrr) rrrrrrrr cb_suppressrrrrrr6s@       zAsyncExitStack.__aexit__N)r+r,r-r.rrrrrrrvrr5r6rrrrr Ls     r c@s:eZdZdZd ddZddZddZd d Zd d 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)rrrrrrLrmznullcontext.__init__cCrnr:rrrrrrroznullcontext.__enter__cGrr:rrexcinforrrr!rznullcontext.__exit__crtr:rrrrrr5ruznullcontext.__aenter__csdSr:rrrrrr6rznullcontext.__aexit__r:) r+r,r-r.rLrr!r5r6rrrrr s  r )!r.r1r|r$ collectionsr functoolsrtypesrr__all__ABCr r objectrrFrGrNr]rrr rrwrrrrrr r rrrrsH    @A!!PE