a jCi0`@sZdZddlZddlZddlZddlmZddlmZddlm Z m Z gdZ Gdddej Z Gd d d ej ZGd d d eZGd ddZGdddee eZGdddeeZddZddZGddde ZGddde ZGdddeZGdddeZGdd d e ZGd!d"d"ZGd#d$d$ee ZGd%d&d&eeZGd'd(d(e ZdS))z4Utilities for with-statement contexts. See PEP 343.N)dequewraps) MethodType GenericAlias) asynccontextmanagercontextmanagerclosing nullcontextAbstractContextManagerAbstractAsyncContextManagerAsyncExitStackContextDecorator ExitStackredirect_stdoutredirect_stderrsuppressc@s:eZdZdZeeZddZej ddZ eddZ dS) r z,An abstract base class for context managers.cCs|Sz0Return `self` upon entering the runtime context.selfrr&/usr/local/lib/python3.9/contextlib.py __enter__sz AbstractContextManager.__enter__cCsdSz9Raise any exception triggered within the runtime context.Nrrexc_type exc_value tracebackrrr__exit__szAbstractContextManager.__exit__cCs|turt|ddStS)Nrr)r _collections_abc_check_methodsNotImplementedclsCrrr__subclasshook__sz'AbstractContextManager.__subclasshook__N) __name__ __module__ __qualname____doc__ classmethodr__class_getitem__rabcabstractmethodrr%rrrrr s r c@s:eZdZdZeeZddZej ddZ eddZ dS) r z9An abstract base class for asynchronous context managers.cs|Srrrrrr __aenter__+sz&AbstractAsyncContextManager.__aenter__csdSrrrrrr __aexit__/sz%AbstractAsyncContextManager.__aexit__cCs|turt|ddStS)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 eZdZdZddZddZdS)rzJA base class or mixin that enables context managers to work as decorators.cCs|S)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_cmcstfdd}|S)Ncs:|i|WdS1s,0YdSN)r0argskwdsfuncrrrinnerLs z(ContextDecorator.__call__..innerr)rr6r7rr5r__call__KszContextDecorator.__call__N)r&r'r(r)r0r8rrrrr<s rc@s eZdZdZddZddZdS)_GeneratorContextManagerBasezBShared functionality for @contextmanager and @asynccontextmanager.cCsN||i||_||||_|_|_t|dd}|durDt|j}||_dS)Nr))genr6r3r4getattrtyper))rr6r3r4docrrr__init__Vs   z%_GeneratorContextManagerBase.__init__cCs||j|j|jSr1) __class__r6r3r4rrrrr0dsz)_GeneratorContextManagerBase._recreate_cmN)r&r'r(r)r>r0rrrrr9Ssr9c@s eZdZdZddZddZdS)_GeneratorContextManagerz%Helper for @contextmanager decorator.cCs:|`|`|`z t|jWSty4tddYn0dSNzgenerator didn't yield)r3r4r6nextr: StopIteration RuntimeErrorrrrrrrs    z"_GeneratorContextManager.__enter__c Cs |dur6zt|jWnty*YdS0tdn|durD|}z|j|||Wnty}z||uWYd}~Sd}~0ty}zF||urWYd}~dSt|tr|j|urWYd}~dSWYd}~nz|jIdHWnty0YdS0tdn|durL|}z|j|||IdHWnty}z||uWYd}~Sd}~0ty}zJ||urWYd}~dSt|ttfr|j|urWYd}~dSWYd}~n): try: yield finally: This makes this: with some_generator() as : equivalent to this: try: = finally: cs t||Sr1)r@r2r6rrhelperszcontextmanager..helperrr6rSrrRrrsrcstfdd}|S)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: cs t||Sr1)rNr2rRrrrS&sz#asynccontextmanager..helperrrTrrRrr src@s(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() cCs ||_dSr1thing)rrVrrrr>=szclosing.__init__cCs|jSr1rUrrrrr?szclosing.__enter__cGs|jdSr1)rVclose)rexc_inforrrrAszclosing.__exit__Nr&r'r(r)r>rrrrrrr ,sr c@s(eZdZdZddZddZddZdS)_RedirectStreamNcCs||_g|_dSr1) _new_target _old_targets)rZ new_targetrrrr>Isz_RedirectStream.__init__cCs*|jtt|jtt|j|j|jSr1)r\appendr;sys_streamsetattrr[rrrrrNsz_RedirectStream.__enter__cCstt|j|jdSr1)r`r^r_r\poprZexctypeZexcinstZexctbrrrrSsz_RedirectStream.__exit__)r&r'r(r_r>rrrrrrrZEsrZc@seZdZdZdZdS)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_rrrrrWs rc@seZdZdZdZdS)rzCContext manager for temporarily redirecting stderr to another file.stderrNrdrrrrrgsrc@s(eZdZdZddZddZddZdS) 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 cGs ||_dSr1) _exceptions)rZ exceptionsrrrr>xszsuppress.__init__cCsdSr1rrrrrr{szsuppress.__enter__cCs|duot||jSr1) issubclassrfrbrrrr~s zsuppress.__exit__NrYrrrrrms rc@sbeZdZdZeddZeddZddZdd Zd d Z d d Z ddZ ddZ dddZ dS)_BaseExitStackz.A base class for ExitStack and AsyncExitStack.cCs t||Sr1rcmcm_exitrrr_create_exit_wrappersz#_BaseExitStack._create_exit_wrappercsfdd}|S)NcsidSr1rrrMtbr3callbackr4rr _exit_wrappersz8_BaseExitStack._create_cb_wrapper.._exit_wrapperrrqr3r4rrrrpr_create_cb_wrappersz!_BaseExitStack._create_cb_wrappercCs t|_dSr1)r_exit_callbacksrrrrr>sz_BaseExitStack.__init__cCst|}|j|_t|_|S)z@Preserve the context stack by transferring it to a new instance.)r<rur)rZ new_stackrrrpop_alls z_BaseExitStack.pop_allcCs@t|}z |j}Wnty.||Yn0||||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). )r<rAttributeError_push_exit_callback _push_cm_exitrexitZ_cb_typeZ 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. )r<rrryrrkZ_cm_type_exitresultrrr enter_contexts   z_BaseExitStack.enter_contextcOs,|j|g|Ri|}||_|||S)z\Registers an arbitrary callback and arguments. Cannot suppress exceptions. )rt __wrapped__rxrrqr3r4rrrrrrqs z_BaseExitStack.callbackcCs|||}||ddS)z;Helper to correctly register callbacks to __exit__ methods.TN)rmrxrrkrlrrrrrrys z_BaseExitStack._push_cm_exitTcCs|j||fdSr1)rur])rrqis_syncrrrrxsz"_BaseExitStack._push_exit_callbackN)T)r&r'r(r) staticmethodrmrtr>rvr|rrqryrxrrrrrhs   rhc@s(eZdZdZddZddZddZdS) 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. cCs|Sr1rrrrrrszExitStack.__enter__c s|ddu}tdfdd}d}d}|jr|j\}}|sHJz||r^d}d}d}Wq,t}||d|dd}|}Yq,0q,|rz|dj} |dWnty| |d_Yn0|o|S)Nrcs4|j}|dus||urdS|ur$q*|}q||_dSr1 __context__Znew_excZold_excZ exc_contextZ frame_excrr_fix_exception_contextsz2ExitStack.__exit__.._fix_exception_contextFTNNNr^rXrurarrI) r exc_details received_excrsuppressed_exc pending_raisercbnew_exc_details fixed_ctxrrrrs4        zExitStack.__exit__cCs|ddddSz%Immediately unwind the context stack.N)rrrrrrWszExitStack.closeN)r&r'r(r)rrrWrrrrrs 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. cCs t||Sr1rirjrrr_create_async_exit_wrapper-sz)AsyncExitStack._create_async_exit_wrappercsfdd}|S)NcsiIdHdSr1rrnrprrrr3sz>AsyncExitStack._create_async_cb_wrapper.._exit_wrapperrrsrrpr_create_async_cb_wrapper1sz'AsyncExitStack._create_async_cb_wrappercs.t|}|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)r<r/r._push_async_cm_exitr}rrrenter_async_context7s  z"AsyncExitStack.enter_async_contextcCsBt|}z |j}Wnty0||dYn0||||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/rwrxrrzrrrpush_async_exitCs   zAsyncExitStack.push_async_exitcOs.|j|g|Ri|}||_||d|S)zfRegisters an arbitrary coroutine function and arguments. Cannot suppress exceptions. F)rrrxrrrrpush_async_callbackUs z"AsyncExitStack.push_async_callbackcs|dddIdHdSr)r/rrrraclosebszAsyncExitStack.aclosecCs|||}||ddS)zLHelper to correctly register coroutine function to __aexit__ method.FN)rrxrrrrrfs z"AsyncExitStack._push_async_cm_exitcs|Sr1rrrrrr.lszAsyncExitStack.__aenter__c s|ddu}tdfdd}d}d}|jr|j\}}z0|rP||}n||IdH}|rnd}d}d}Wq,t} || d|dd}| }Yq,0q,|rz|dj} |dWnty| |d_Yn0|o|S)Nrrcs4|j}|dus||urdS|ur$q*|}q||_dSr1rrrrrrusz8AsyncExitStack.__aexit__.._fix_exception_contextFTrr) rrrrrrrrZ cb_suppressrrrrrr/os8         zAsyncExitStack.__aexit__N)r&r'r(r)rrrrrrrrr.r/rrrrr s     r c@s*eZdZdZd ddZddZddZdS) 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 NcCs ||_dSr1 enter_result)rrrrrr>sznullcontext.__init__cCs|jSr1rrrrrrsznullcontext.__enter__cGsdSr1r)rZexcinforrrrsznullcontext.__exit__)NrYrrrrr s r )r)r,r^r collectionsr functoolsrtypesrr__all__ABCr r objectrr9r@rNrrr rZrrrrhrr r rrrrs>   A >!!PE