python (3.12.0)
ˑej " d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl m
Z
m Z g dZ G d dej Z G d d
ej Z G d d e Z G d
de Z G d d Z G d deee Z G d deee Zd Zd Z G d de Z G d de Z G d d e Z G d d e Z G d d e Z G d! d"e Z G d# d$ Z G d% d&e e Z G d' d(e e Z G d) d*ee Z! G d+ d,e Z"y)-z4Utilities for with-statement contexts. See PEP 343. N)dequewraps)
MethodType GenericAlias)asynccontextmanagercontextmanagerclosing nullcontextAbstractContextManagerAbstractAsyncContextManagerAsyncExitStackContextDecorator ExitStackredirect_stdoutredirect_stderrsuppressaclosingchdirc Z e Zd ZdZ ee Zd Zej d Z
ed Z y)r z,An abstract base class for context managers.c | S z0Return `self` upon entering the runtime context. selfs >/BuggyBox/python/3.12.0/bootstrap/lib/python3.12/contextlib.py __enter__z AbstractContextManager.__enter__ s c yz9Raise any exception triggered within the runtime context.Nr r exc_type exc_value tracebacks r __exit__z AbstractContextManager.__exit__ s r c L | t u rt j |dd S t S )Nr r% )r _collections_abc_check_methodsNotImplementedclsCs r __subclasshook__z'AbstractContextManager.__subclasshook__ s& ( (#221k:N N r N) __name__
__module__ __qualname____doc__ classmethodr __class_getitem__r abcabstractmethodr% r- r r r r r sC 6#L1 r r c Z e Zd ZdZ ee Zd Zej d Z
ed Z y)r
z9An abstract base class for asynchronous context managers.c K | S wr r r s r
__aenter__z&AbstractAsyncContextManager.__aenter__- s c K ywr r r! s r __aexit__z%AbstractAsyncContextManager.__aexit__1 s c L | t u rt j |dd S t S )Nr8 r; )r
r' r( r) r* s r r- z,AbstractAsyncContextManager.__subclasshook__6 s- - -#221l3>@
@ r N) r. r/ r0 r1 r2 r r3 r8 r4 r5 r; r- r r r r
r
' sC C#L1 r r
c e Zd ZdZd Zd Zy)r zJA base class or mixin that enables context managers to work as decorators.c | 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.
r r s r _recreate_cmz ContextDecorator._recreate_cmA s r c 2 t fd }|S )Nc ` j 5 | i |cd d d S # 1 sw Y y xY wNr@ argskwdsfuncr s r innerz(ContextDecorator.__call__.<locals>.innerN s1 ""$
+T*T*
+
+
+s $-r r rH rI s `` r __call__zContextDecorator.__call__M s t +
+ r Nr. r/ r0 r1 r@ rK r r r r r > s P
r r c e Zd ZdZd Zd Zy)AsyncContextDecoratorzPA base class or mixin that enables async context managers to work as decorators.c | S )z-Return a recreated instance of self.
r r s r r@ z"AsyncContextDecorator._recreate_cmX s r c 2 t fd }|S )Nc K j 4 d { | i | d { cd d d d { S 7 %7 7 # 1 d { 7 sw Y y xY wwrC rD rE s r rI z-AsyncContextDecorator.__call__.<locals>.inner^ sV ((*
1
1 !4 04 00
1
1
10
1
1
1
1sP A>A AA A AAA AAA
A
AAr rJ s `` r rK z AsyncContextDecorator.__call__] s t 1
1 r NrL r r r rN rN U s V
r rN c e Zd ZdZd Zd Zy) _GeneratorContextManagerBasezBShared functionality for @contextmanager and @asynccontextmanager.c ||i || _ |||c| _ | _ | _ t |dd }|t | j }|| _ y )Nr1 )genrH rF rG getattrtyper1 )r rH rF rG docs r __init__z%_GeneratorContextManagerBase.__init__h sR &&*.d' 49didIt, ;t*$$C r c d | j | j | j | j S rC ) __class__rH rF rG r s r r@ z)_GeneratorContextManagerBase._recreate_cmv s# ~~diiDII>>r N)r. r/ r0 r1 rY r@ r r r rS rS e s L ?r rS c e Zd ZdZd Zd Zy)_GeneratorContextManagerz%Helper for @contextmanager decorator.c l | ` | `| ` t | j S # t
$ r
t
d d w xY wNzgenerator didn't yield)rF rG rH nextrU
StopIteration RuntimeErrorr s r r z"_GeneratorContextManager.__enter__ sD
Ity$) C> ! C 78d B Cs 3c |! t | j t d | | } | j j | t d # t $ r Y yw xY w# t $ r}||ucY d }~S d }~wt $ r@}||u r ||_ Y d }~yt
|t r|j |u r ||_ Y d }~y d }~wt $ r}||ur ||_ Y d }~yd }~ww xY w)Ngenerator didn't stopFz#generator didn't stop after throw()) r` rU rb ra throw
__traceback__
isinstance __cause__
BaseExceptionr typvaluer$ excs r r% z!_GeneratorContextManager.__exit__ s ;
<TXX ##:;;} #
u%F DE E[ !
!
( %''
%<(1C% um4
.*3E'
e#$-!
sR A A# A A # C ,A5/C 5 C B<%B<;B<< C CC N)r. r/ r0 r1 r r% r r r r] r] } s
0C1Fr r] c e Zd ZdZd Zd Zy) _AsyncGeneratorContextManagerz*Helper for @asynccontextmanager decorator.c K | ` | `| ` t | j d { S 7 # t
$ r
t
d d w xY wwr_ )rF rG rH anextrU StopAsyncIterationrb r s r r8 z(_AsyncGeneratorContextManager.__aenter__ sM
Ity$) C txx ( ((! C 78d B Cs# A) ') A) ?Ac K |) t | j d { t d | | } | j j | d { t d 7 G# t $ r Y yw xY w7 # t $ r}||ucY d }~S d }~wt $ rF}||u r ||_ Y d }~yt
|t t f r|j |u r ||_ Y d }~y d }~wt $ r}||ur ||_ Y d }~yd }~ww xY ww)Nrd Fz$generator didn't stop after athrow())
rq rU rb rr athrowrf rg ra rh ri rj s r r; z'_AsyncGeneratorContextManager.__aexit__ s ;
<DHHo%% ##:;;} #
hhooe,,,F EF F] &%
-%
( %''
%<(1C% u}6H&IJ
.*3E'
e#$-!
s C=A( A&A( C= A9 A7A9 C=&A( ( A41C=3A44C=7A9 9 C:B C:C= C: C"C='+CC=C C:$ C50C=5C::C=N)r. r/ r0 r1 r8 r; r r r ro ro s
5C1Gr ro c . t fd }|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 | | S rC )r] rF rG rH s r helperz contextmanager.<locals>.helper s 'dD99r r rH rx s ` r r r s 6 4[: : Mr c . t fd }|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>
c t | | S rC )ro rw s r rx z#asynccontextmanager.<locals>.helper@ s ,T4>>r r ry s ` r r r % s 6 4[? ? Mr c " e Zd ZdZd Zd Zd Zy)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()
c || _ y rC thingr r s r rY zclosing.__init__W
r c | j S rC r~ r s r r zclosing.__enter__Y s zzr c 8 | j j y rC )r closer exc_infos r r% zclosing.__exit__[ s
r Nr. r/ r0 r1 rY r r% r r r r
r
F s r r
c " e Zd ZdZd Zd Zd Zy)r a 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()
c || _ y rC r~ r s r rY zaclosing.__init__q r r c " K | j S wrC r~ r s r r8 zaclosing.__aenter__s s zz
c T K | j j d { y 7 wrC )r acloser s r r; zaclosing.__aexit__u s jj !!!s (&(N)r. r/ r0 r1 rY r8 r; r r r r r _ s ""r r c " e Zd ZdZd Zd Zd Zy)_RedirectStreamNc || _ g | _ y rC ) _new_target _old_targets)r
new_targets r rY z_RedirectStream.__init__} s % r c | j j t t | j t t | j | j | j S rC )r appendrV sys_streamsetattrr r s r r z_RedirectStream.__enter__ sC dll!;<T\\4#3#34 r c j t t | j | j j y rC )r r r r pop)r exctypeexcinstexctbs r r% z_RedirectStream.__exit__ s! T\\4#4#4#8#8#:;r )r. r/ r0 r rY r r% r r r r r y s G
<r r c e Zd ZdZdZy)r aA 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)
stdoutNr. r/ r0 r1 r r r r r r s
Gr r c e Zd ZdZdZy)r zCContext manager for temporarily redirecting stderr to another file.stderrNr r r r r r s
MGr r c " e Zd ZdZd Zd Zd Zy)r a? 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 || _ y rC ) _exceptions)r
exceptionss r rY zsuppress.__init__ s
%r c y rC r r s r r zsuppress.__enter__ r c |y t || j ryt |t r#|j | j \ }}|y|y)NTF)
issubclassr ExceptionGroupsplit)r r r r matchrests r r% zsuppress.__exit__ sQ ? gt / / 0 g~ .!--(8(89KE4|Jr Nr r r r r r s &
r r c \ e Zd ZdZed Zed Zd Zd Zd Z d Z
d Z d Z d d
Z
y )
_BaseExitStackz.A base class for ExitStack and AsyncExitStack.c t || S rC r cmcm_exits r _create_exit_wrapperz#_BaseExitStack._create_exit_wrapper '2&&r c fd}|S )Nc i y rC r r" rm tbrF callbackrG s r
_exit_wrapperz8_BaseExitStack._create_cb_wrapper.<locals>._exit_wrapper s d #d #r r r rF rG r s ``` r _create_cb_wrapperz!_BaseExitStack._create_cb_wrapper s $ r c " t | _ y rC )r _exit_callbacksr s r rY z_BaseExitStack.__init__ s $w r c f t | }| j |_ t | _ |S )z@Preserve the context stack by transferring it to a new instance.)rW r r )r new_stacks r pop_allz_BaseExitStack.pop_all s- DJL $($8$8 ! $w r c t | } |j }| j || |S # t $ r | j | Y |S w xY w)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).
)rW r%
_push_cm_exitAttributeError_push_exit_callbackr exit_cb_type exit_methods r pushz_BaseExitStack.push sZ : 2"++K
t[ 1 + $ $T * +s - A
A c t | } |j }|j } || }| j || |S # t $ r( t d|j
d|j d dw xY w)zEnters the supplied context manager.
If successful, also pushes its __exit__ method as a callback and
returns the result of the __enter__ method.
'.z6' object does not support the context manager protocolN)rW r r% r TypeErrorr/ r0 r r r r+ _enter_exitresults r
enter_contextz _BaseExitStack.enter_context s 2h S]]FLLE 2u%
Sa /q1A1A0B CG H INR
S Ss A 1A2c b | j |g|i |}||_ | j | |S )z\Registers an arbitrary callback and arguments.
Cannot suppress exceptions.
)r __wrapped__r r r rF rG r s r r z_BaseExitStack.callback s=
0//H4H4H
%-
! /r c L | j || }| j |d y)z;Helper to correctly register callbacks to __exit__ methods.TN)r r r r r r s r r z _BaseExitStack._push_cm_exit s$ 11"g>
5r c > | j j ||f y rC )r r )r r is_syncs r r z"_BaseExitStack._push_exit_callback s ##Wh$78r N)T)r. r/ r0 r1 staticmethodr r rY r r r r r r r r r r r sN 8' '
'(& 6
9r r c " e Zd ZdZd Zd Zd Zy)r a 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 | S rC r r s r r zExitStack.__enter__( s r c
|d d u}t j d
fd}d}d}| j r:| j j \ }}|sJ || rd}d}d}| j r:|r |d j } |d |xr |S # t j } ||d |d d}|}Y UxY w# t
$ r |d _ w xY w)Nr c L | j }|||u ry |u r || _ y |} #rC __context__new_excold_exc exc_context frame_excs r _fix_exception_contextz2ExitStack.__exit__.<locals>._fix_exception_context1 B % 1 1 &+*@ )+ #*G & r FTNNNr r r r r ri ) r exc_details received_excr suppressed_exc
pending_raiser cbnew_exc_details fixed_ctxr s @r r% zExitStack.__exit__+ s "1~T1 LLN1% *
"" ..224KGRN
.{#%)N$)M"4K ""
(N 6 6 !!n$ ..
."%,,.&q'9;q>J $
- !
-6 A*
s B 2B: )B7:Cc * | j ddd yz%Immediately unwind the context stack.N)r% r s r r zExitStack.close\ s
dD$'r N)r. r/ r0 r1 r r% r r r r r r s //b(r r c Z e Zd ZdZed Zed Zd Zd Zd Z d Z
d Z d Z d
Z
y ) 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.
c t || S rC r r s r _create_async_exit_wrapperz)AsyncExitStack._create_async_exit_wrappero r r c fd}|S )Nc 2 K i d { y 7 wrC r r s r r z>AsyncExitStack._create_async_cb_wrapper.<locals>._exit_wrapperu s D)D) ) )s r r s ``` r _create_async_cb_wrapperz'AsyncExitStack._create_async_cb_wrappers s * r c K t | } |j }|j } || d{ }| j || |S # t $ r( t d|j
d|j d dw xY w7 Lw)zEnters the supplied async context manager.
If successful, also pushes its __aexit__ method as a callback and
returns the result of the __aenter__ method.
r r zC' object does not support the asynchronous context manager protocolN)rW r8 r; r r r/ r0 _push_async_cm_exitr s r enter_async_contextz"AsyncExitStack.enter_async_contexty s 2h '^^FMME
bz! U+
'a /q1A1A0B CT U "&
' ' "s% BA BA?B 1A<<Bc t | } |j }| j || |S # t $ r | j |d Y |S w xY w)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)rW r; r r r r s r push_async_exitz AsyncExitStack.push_async_exit s\ : 8",,K
$ $T; 7 2 $ $T5 1 2s - A A c d | j |g|i |}||_ | j |d |S )zfRegisters an arbitrary coroutine function and arguments.
Cannot suppress exceptions.
F)r r r r s r push_async_callbackz"AsyncExitStack.push_async_callback s?
655hNNN
%-
! 6r c F K | j ddd d{ y7 wr )r; r s r r zAsyncExitStack.aclose s nnT4...s ! !c L | j || }| j |d y)zLHelper to correctly register coroutine function to __aexit__
method.FN)r r r s r r z"AsyncExitStack._push_async_cm_exit s& 77GD
6r c K | S wrC r r s r r8 zAsyncExitStack.__aenter__ s r9 c K |d d u}t j d fd}d}d}| j rH| j j \ }} |r || }n
|| d { }|rd}d}d}| j rH|r |d j }
|d |xr |S 7 6# t j } || d |d d}| }Y WxY w# t
$ r
|d _ w xY ww)Nr r c L | j }|||u ry |u r || _ y |} #rC r r s r r z8AsyncExitStack.__aexit__.<locals>._fix_exception_context r r FTr r ) r r r r r r r r cb_suppressr r r s @r r; zAsyncExitStack.__aexit__ s "1~T1 LLN1% *
"" ..224KGR
."$k"2K(*K(8"8K %)N$)M"4K ""$
(N 6 6 !!n$ ..+ #9
."%,,.&q'9;q>J $
- !
-6 A*
sN AC$B %B & B 2 C$?C$C C$ B )C C$ C!!C$N)r. r/ r0 r1 r r r r r r r r r8 r; r r r r r b sR
' '
$$ /7 3/r r c 0 e Zd ZdZddZd Zd Zd Zd Zy) 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
Nc || _ y rC enter_result)r r s r rY znullcontext.__init__ s
(r c | j S rC r
r s r r znullcontext.__enter__ s r c y rC r r excinfos r r% znullcontext.__exit__ r r c " K | j S wrC r
r s r r8 znullcontext.__aenter__ s r c K y wrC r r s r r; znullcontext.__aexit__ s r< rC ) r. r/ r0 r1 rY r r% r8 r; r r r r r s )!
!
r r c " e Zd ZdZd Zd Zd Zy)r zHNon thread-safe context manager to change the current working directory.c || _ g | _ y rC )path_old_cwd)r r s r rY zchdir.__init__ s
r c | j j t j t j | j
y rC )r r osgetcwdr r r s r r zchdir.__enter__ s*
RYY[)
r c ^ t j | j j y rC )r r r r r s r r% zchdir.__exit__ s
""$%r Nr r r r r r s R &r r )#r1 r4 r r r' collectionsr functoolsr typesr r __all__ABCr r
objectr rN rS r] ro r r r
r r r r r r r r r r r r r <module>r# s= :
* SWW , #'' .v .
F
? ?0AF AFFAG AGH B B$ 2"* "4<, <$
o
o $% $NQ9 Q9jA( 6 A(JH/^%@ H/V
(*E
6 & " &r 
Browse
Usage
Versions