+ }jU  Rt^RIHt^RIt^RIt^RIt^RIHt^RIH t ^RI H t ] 'd^RI H t !RR4t!R R 4t]P RR l4t!R R 4t]P R4tRRltRRltR#)aDeterministic cancellation testing for the asyncio dialects. An asyncio task may be cancelled at any ``await``, and reproducing a specific one of those points by racing ``task.cancel()`` against real network traffic is unreliable. Here the choice is made exact. :func:`.greenlet_spawn` drives every await performed by an asyncio-driven SQLAlchemy operation, ``connect()`` included, so instrumenting the greenlet it switches into gives a stable enumeration of a scenario's IO points, and cancelling at point ``N`` is reproducible run to run. What is asserted afterwards is that nothing was leaked: every DBAPI connection a pool creates must eventually be passed successfully through ``Pool._close_connection()``. A connection that isn't has become unreachable, and for an asyncio driver the garbage collector cannot close it either, since closing needs the event loop. Pool *availability* is deliberately not asserted. A cancellation can leave a record checked out until the ``_ConnectionFairy`` is collected and ``_finalize_fairy()`` hands it back, so what the pool has available immediately afterwards is a function of garbage collection timing rather than of anything the dialect did. ) annotationsN)mock)exc) have_greenlet)_AsyncIoGreenletc*]tRt^/tRtRtRtRtRtR#)_InstrumentedAwaitablez6An awaitable that invokes ``hook`` when it is awaited.c WnW nR#N awaitablehook)selfr r s&&&`/home/luca/screen-checking/.venv/lib/python3.14/site-packages/sqlalchemy/testing/cancellation.py__init___InstrumentedAwaitable.__init__4s " c lVPVP4VPP4#r )r r __await__rs&rr _InstrumentedAwaitable.__await__8s% $..!~~''))rr N) __name__ __module__ __qualname____firstlineno____doc__ __slots__rr__static_attributes__rrrr/s@%I*rrc*]tRt^=tRtRRltRtRtR#) AwaitPointszACounts await points, and cancels the running task at one of them.Nc .^VnWnRVnR#)N)count cancel_at cancelled_at)rr$s&&rrAwaitPoints.__init__@s " rc V;P^, unVPVP8wdR#\VR\V44Vn\ P !4pVfQR4hVP4R#)NrzQcancellation can only be delivered to an operation running within an asyncio task)r#r$getattrreprr%asyncio current_taskcancel)rr tasks&& r__call__AwaitPoints.__call__Esh a :: ' #I~tIO##%  %  r)r$r%r#r )rrrrrrr/rrrrr r =sK! rr c #aaaa"\V4o\Po\PoV3RloVV3RlpVV3Rlp\P P \RV4;_uu_4\P P \RV4;_uu_4SxRRR4RRR4R# +'giL;i +'giR#;i5i)ziCount the await points performed within the block, cancelling the running task at ``cancel_at`` if given.cD<VP'dV#\VS4#r )deadr)greenletresultpointss&&r instrument await_points..instrumentas  ===M%ff55rc*<S!VS!V.VO5/VB4#r r)rargkwr7 real_switchs&*,rswitchawait_points..switchhs$ D =3 =" =>>rc&<S!VS!V.VO5!4#r r)rr:r7 real_throws&*rthrowawait_points..throwks$ 4 6# 677rr=rAN)r rr=rArpatchobject)r$r=rAr7r6r<r@s& @@@@r await_pointsrEXs  #F"))K!''J6?8   (F   zz)7E:: ;  ::   s6A-C3.C !B8 &C . C8 C C  C  Cc0]tRt^ttRtRt]R4tRtR#)ConnectionAccountingzMRecords which DBAPI connections a pool created and which it managed to close.c B\4Vn\4VnR#r )setcreatedclosedrs&rrConnectionAccounting.__init__xsu e rc <VPVP, #)z._invoke_creators)',/0r terminateFcP<S!WR7SPPV4R#))rZN)rKrS)rUrZrV real_closes&$r_close_connection0connection_accounting.._close_connections!#9./rrXr]N)rGpoolrXr]rrCrD)enginer_rXr]rVr\rWs& @@@rconnection_accountingras&'J ;;D''L''J 000       zz24EFFG  FF   s6A*C/*CB0 C& C0 C ;C C  Cc "V!4p\V4;_uu_4pV'dV!V4GRjxL \V4;_uu_4p\P!V!V44GRjxL RRR4\ P!4VP4GRjxL VP'd>XR\VP4\VP43,3uuRRR4#RRR4XR3#LL \dTP fhLi;i +'giL;iL \PdLi;i +'giXR3#;i5i)a!Run ``scenario`` against a fresh engine, optionally cancelling it. ``engine_factory`` is a zero-argument callable returning a new :class:`_asyncio.AsyncEngine`; ``scenario`` is a coroutine function taking that engine. If ``warm`` is True the scenario is run once un-cancelled first, so that the await points counted are those of checkout, execution and return-to-pool rather than those of ``connect()``. Returns the :class:`.AwaitPoints` for the run, and a description of what the cancellation cost the pool, or ``None`` if it cost nothing. NzE%d of %d connection(s) were left open with nothing able to close them)rarEr+ create_task BaseExceptionr%gccollectdisposerSQLAlchemyErrorrNlenrJ)engine_factoryscenarior$warmr`rVr6s&&&& r run_scenariormsH F v & &* 6" " " ) $ $ ))(6*:;;;%  .." " "     z(()3z/A/A+BCD; ' &8 9 'F 4<C #< &&./ % $$ #""   / ' &F 4<sE+EDE D% D*D +D/E D: D8!D:%E72E) E+5 E+EDD" D% !D" "D% % D5 0E8D::EEEE E( E+c"\WVR7GRjxL wr4VPp.p\^V^,4FEp\WWrR7GRjxL wr8VfK VPRWuVPV3,4KG V#LrL95i)aCancel ``scenario`` at each of its await points in turn. Returns a list of strings describing what went wrong, empty if every cancellation point was handled cleanly. The strings are meant to be read in an assertion failure:: eq_(await sweep(engine_factory, scenario), []) )rlN)r$rlz'cancel at await point %d of %d (%s): %s)rmr#rangeappendr%) rjrkrlr6_totalreportedindexfailures &&& rsweeprvs#>$GGIF LLEHq%!)$ , !     OO9!4!4g>?  % OH  s'B B:B BB ,B B r )NF)F)r __future__rr+ contextlibreunittestrrutil.concurrencyrutil._concurrency_py3krrr contextmanagerrErGrarmrvrrrr~s0# ,9 * *6 6 * * :2jr