o X|je@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/local/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>Zdocrrr__init__fs    z%_GeneratorContextManagerBase.__init__cCs||j|j|jSr:) __class__r@r=r>rrrrr8tsz)_GeneratorContextManagerBase._recreate_cmN)r+r,r-r.rKr8rrrrrGcs 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())rOrHrPrQthrow isinstance __cause__ BaseExceptionrtypvaluer excrrrr!s<    z!_GeneratorContextManager.__exit__N)r+r,r-r.rr!rrrrrM{ rMc@r7)_AsyncGeneratorContextManagerz*Helper for @asynccontextmanager decorator.cs:|`|`|`z t|jIdHWStytddwrN)r=r>r@anextrHStopAsyncIterationrQrrrrr5s   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)NFrRz$generator didn't stop after athrow()) r]rHr^rQathrowrTrPrUrVrWrrrr6s>    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:)rMr<r@rrhelper zcontextmanager..helperrr@rcrrbrrrcr`)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: crar:)r\r<rbrrrc8rdz#asynccontextmanager..helperrrerrbrrrfrc@(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:thingrrjrrrrKO zclosing.__init__cC|jSr:rirrrrrQzclosing.__enter__cGs|jdSr:)rjcloserexc_inforrrr!Sszclosing.__exit__Nr+r,r-r.rKrr!rrrrr >s  r c@rg) 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() cCrhr:rirkrrrrKirlzaclosing.__init__c|jSr:rirrrrr5kzaclosing.__aenter__cs|jIdHdSr:)rjacloserprrrr6mszaclosing.__aexit__N)r+r,r-r.rKr5r6rrrrrWs  rc@s(eZdZdZddZddZddZdS)_RedirectStreamNcCs||_g|_dSr:) _new_target _old_targets)rZ new_targetrrrrKus z_RedirectStream.__init__cCs*|jtt|jtt|j|j|jSr:)rxappendrIsys_streamsetattrrwrrrrrzsz_RedirectStream.__enter__cCstt|j|jdSr:)r|rzr{rxpoprZexctypeZexcinstZexctbrrrr!sz_RedirectStream.__exit__)r+r,r-r{rKrr!rrrrrvqs  rvc@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@rg) 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 cGrhr:) _exceptions)rZ exceptionsrrrrKrlzsuppress.__init__cCdSr:rrrrrrzsuppress.__enter__cCs|duo t||jSr:) issubclassrr~rrrr!s zsuppress.__exit__Nrrrrrrrs   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:rrrZtbr=callbackr>rr _exit_wrappersz8_BaseExitStack._create_cb_wrapper.._exit_wrapperrrr=r>rrrr_create_cb_wrapperz!_BaseExitStack._create_cb_wrappercCs t|_dSr:)r_exit_callbacksrrrrrKs z_BaseExitStack.__init__cCst|}|j|_t|_|S)z@Preserve the context stack by transferring it to a new instance.)rJrr)rZ 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_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. )rJr!rrrrZ_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:)rry)rris_syncrrrrsz"_BaseExitStack._push_exit_callbackN)T)r+r,r-r. staticmethodrrrKrrrrrrrrrrrs   rc@rg) 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__Znew_excZold_excZ exc_contextZ frame_excrr_fix_exception_context z2ExitStack.__exit__.._fix_exception_contextFTNNNrzrqrr}rrV) r exc_details received_excrsuppressed_exc pending_raisercbnew_exc_details fixed_ctxrrrr!s:      zExitStack.__exit__cCs|ddddSz%Immediately unwind the context stack.N)r!rrrrroFszExitStack.closeN)r+r,r-r.rr!rorrrrrs   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)r6rrrrruszAsyncExitStack.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) rrrrrrrrZ cb_suppressrrrrrr6s@       zAsyncExitStack.__aexit__N)r+r,r-r.rrrrrrrurr5r6rrrrr 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 NcCrhr: enter_result)rrrrrrKrlznullcontext.__init__cCrmr:rrrrrrrnznullcontext.__enter__cGrr:rrZexcinforrrr!rznullcontext.__exit__crsr:rrrrrr5rtznullcontext.__aenter__csdSr:rrrrrr6rznullcontext.__aexit__r:) r+r,r-r.rKrr!r5r6rrrrr s  r )!r.r1rzr$Z collectionsr functoolsrtypesrr__all__ABCr r objectrrFrGrMr\rrr rrvrrrrrr r rrrrsH    @A!!PE