+ V@imTaRt50tRt^RIt^RIt^RIt^RIt^RIt^RIt^RI t ^RI t ^RI t ^RI t ^RI t ^RIt^RIHt^RIHtHt^RI HtHtHtHtHtHtHtHtHtHt] P<'d ^RIH t H!t!!RR]4t"]]#]"3,t$]!R4t%] P<'d ] !R 4t&]'!4t(]^kR R lt)]PT!])4!R R ]4t+!RR]+4t,!RR]+4t-RRlt.RRlt/Rs0RRlt1!RR4t2!RR]Pf4t4R#)akBridges between the `asyncio` module and Tornado IOLoop. .. versionadded:: 3.2 This module integrates Tornado with the ``asyncio`` module introduced in Python 3.4. This makes it possible to combine the two libraries on the same event loop. .. deprecated:: 5.0 While the code in this module is still used, it is now enabled automatically when `asyncio` is available, so applications should no longer need to refer to this module directly. .. note:: Tornado is designed to use a selector-based event loop. On Windows, where a proactor-based event loop has been the default since Python 3.8, a selector event loop is emulated by running ``select`` on a separate thread. Configuring ``asyncio`` to use a selector event loop may improve performance of Tornado (but may reduce performance of other ``asyncio``-based libraries in the same process). Nconvert_yielded)IOLoop _Selectable) AnyCallableDictListOptionalProtocolSetTupleTypeVarUnion) TypeVarTupleUnpackc2a]tRt^9toV3RlRltRtVtR#) _HasFilenoc <V^8dQhRS[/#returnint)format __classdict__s":/usr/lib/python3/dist-packages/tornado/platform/asyncio.py __annotate___HasFileno.__annotate__:s   cR#Nselfs&rfileno_HasFileno.fileno:s rr"N)__name__ __module__ __qualname____firstlineno__r%__static_attributes____classdictcell__rs@rrr9s  rr_T_TscV^8dQhRR/#rrNr")rs"rrrIs$rc\FpVP;_uu_4RVnVPP4RRR4VPP R4VPfKmVPP4K \P4R# +'giLp;i \ dLdi;i)TNa) _selector_loops _select_cond_closing_selectornotify_waker_wsendBlockingIOError_threadjoinclear)loops r_atexit_callbackr?Is    %)D "    $ $ &  MM  t $ << # LL         s"B( B;( B8 ; C C c,aa]tRt^^toV3RlV3RlltRV3RlRlltV3RlRltV3RlRltV3R lR ltV3R lR lt V3R lRlt V3RlRlt V3RlRlt V3RlRlt V3RlRltV3RlRltV3RlRltV3RlRltRtVtV;t#)BaseAsyncIOLoopc><V^8dQhRS[PRS[RR/#)r asyncio_loopkwargsrN)asyncioAbstractEventLoopr)rrs"rrBaseAsyncIOLoop.__annotate___s+/%/%#55/%AD/% /%rc P<WnWn\\R4'd1\ V\P 4'd\ V4Vn/Vn\4Vn \4Vn RVn \PP4F-pVP4'gK\PVK/ \PP#W4pW@Jd\%RV RV 24h\&SV`P!R/VBR# \ dKi;i)ProactorEventLoopFzIOLoop z& already associated with asyncio loop Nr")rC selector_loophasattrrE isinstancerIAddThreadSelectorEventLoophandlerssetreaderswritersclosingr_ioloop_for_asynciocopy is_closedKeyError setdefault RuntimeErrorsuper initialize)r$rCrDr> existing_loop __class__s&&, rrZBaseAsyncIOLoop.initialize_s )* 7/ 0 0Z '336 6 "->> --77  --BB   d(()*;*;H*Vt*Vv*V W  ?))>>I ?       s49BB+B(!B%$B%( C6C?CCc0<V^8dQhRS[RS[RS[RR/#rr)rrs"rrrGs-    ), 8;   rc\P!R\4VPP VP \ P!V.VO5/VB4R# \dR#i;i)z&add_callback_from_signal is deprecatedN) warningswarnDeprecationWarningrCrrrrrX)r$rrrDs&&*,radd_callback_from_signal(BaseAsyncIOLoop.add_callback_from_signalsa  >@RS     2 2""I$5$5h$P$P$P    s>A A,+A,c|<V^8dQhRS[S[PP,RS[RS[3,RS[RR/#)rexecutorfunc.rrzasyncio.Future[_T])r concurrentfuturesExecutorrr.r)rrs"rrrG sSHH:--667HsBwH H  Hrc>VPP!W.VO5!#r!)rCrun_in_executor)r$rrrs&&&*rrBaseAsyncIOLoop.run_in_executor s   00G$GGrcL<V^8dQhRS[PPRR/#)rrrN)rrr)rrs"rrrGs+@@Z-?-?-H-H@T@rc8VPPV4#r!)rCset_default_executor)r$rs&&rr$BaseAsyncIOLoop.set_default_executors  55h??r)rCrRrNrPrJrQF)r'r(r)r*rZrgryrrerurrrrrrrrr+r, __classcell__r\rs@@rrArA^s/%/%b""" ! !((&  &&((!!   0  HH@@@rrAcTaa]tRtRtoRtV3RlV3RlltV3RlRltRtVtV;t #)AsyncIOMainLoopia{``AsyncIOMainLoop`` creates an `.IOLoop` that corresponds to the current ``asyncio`` event loop (i.e. the one returned by ``asyncio.get_event_loop()``). .. deprecated:: 5.0 Now used automatically when appropriate; it is no longer necessary to refer to this class directly. .. versionchanged:: 5.0 Closing an `AsyncIOMainLoop` now closes the underlying asyncio loop. c$<V^8dQhRS[RR/#rrDrNr)rrs"rrAsyncIOMainLoop.__annotate__%s??3?4?rc P<\SV`!\P!43/VBR#r!)rYrZrEget_event_loop)r$rDr\s&,rrZAsyncIOMainLoop.initialize%s 7113>v>rc<V^8dQhRR/#r1r")rrs"rrr(s  t rcR#r!r"r#s&r _make_currentAsyncIOMainLoop._make_current(s rr") r'r(r)r*__doc__rZrr+r,rrs@@rrrs# ??   rrcaa]tRtRtoRtV3RlV3RlltR V3RlV3RllltV3RlRltV3R lR ltR t Vt V;t #) AsyncIOLoopi.a!``AsyncIOLoop`` is an `.IOLoop` that runs on an ``asyncio`` event loop. This class follows the usual Tornado semantics for creating new ``IOLoops``; these loops are not necessarily related to the ``asyncio`` default event loop. Each ``AsyncIOLoop`` creates a new ``asyncio.EventLoop``; this object can be accessed with the ``asyncio_loop`` attribute. .. versionchanged:: 6.2 Support explicit ``asyncio_loop`` argument for specifying the asyncio loop to attach to, rather than always creating a new one with the default policy. .. versionchanged:: 5.0 When an ``AsyncIOLoop`` becomes the current `.IOLoop`, it also sets the current `asyncio` event loop. .. deprecated:: 5.0 Now used automatically when appropriate; it is no longer necessary to refer to this class directly. c$<V^8dQhRS[RR/#rr)rrs"rrAsyncIOLoop.__annotate__Hs  3 4 rc <RVnRpRV9d\P!4;VR&p\SV`!R/VBR# \ dTeTP 4hi;i)FNrCr") is_currentrEnew_event_looprYrZ Exceptionrg)r$rDr>r\s&, rrZAsyncIOLoop.initializeHsg  ',3,B,B,D DF> "T  G  ( (    s ?!A c$<V^8dQhRS[RR/#r_ra)rrs"rrrVs''T'd'rcl<VP'dVP4\SV` VR7R#))r`N)r_clear_currentrYrg)r$r`r\s&&rrgAsyncIOLoop.closeVs& ???    !  g &rc<V^8dQhRR/#r1r")rrs"rrr[s22t2rcVP'g#\P!4VnRVn\P !VP4R# \\ 3d RTnLCi;iNT)rrEr old_asynciorXAssertionErrorset_event_looprCr#s&rrAsyncIOLoop._make_current[s\ (#*#9#9#; #DOt001!.1 (#'  (sAA21A2c<V^8dQhRR/#r1r")rrs"rrrds$$T$rc|VP'd*\P!VP4RVnR#R#)FN)rrErrr#s&r_clear_current_hookAsyncIOLoop._clear_current_hookds+ ???  " "4#3#3 4#DO r)rrr) r'r(r)r*rrZrgrrr+r,rrs@@rrr.s72  '' 22$$$rrcXV^8dQhR\PR\P/#)rasyncio_futurerrEFuture)rs"rrrjs"  gnn  rcV#)zConvert an `asyncio.Future` to a `tornado.concurrent.Future`. .. versionadded:: 4.1 .. deprecated:: 5.0 Tornado ``Futures`` have been merged with `asyncio.Future`, so this method is now a no-op. r")rs&rto_tornado_futurerjs  rcXV^8dQhR\PR\P/#)rtornado_futurerr)rs"rrrvs" + +gnn + +rc\V4#)aSConvert a Tornado yieldable object to an `asyncio.Future`. .. versionadded:: 4.1 .. versionchanged:: 4.3 Now accepts any yieldable object, not just `tornado.concurrent.Future`. .. deprecated:: 5.0 Tornado ``Futures`` have been merged with `asyncio.Future`, so this method is now equivalent to `tornado.gen.convert_yielded`. r)rs&rto_asyncio_futurervs > **rcDV^8dQhR\R\P/#rnamer)strtypingr)rs"rrrs"B%B%cB%fjjB%rc VR8wd\R\: RV: 24h\fZ\PR8Xd(\ \ R4'd\ PpM\ Pp!RRV4pVs\#)AnyThreadEventLoopPolicyzmodule z has no attribute win32WindowsSelectorEventLoopPolicycZaa]tRtRtoRtV3RlV3RlltV3RlV3RlltRtVtV;t #)-__getattr__..AnyThreadEventLoopPolicyiaEvent loop policy that allows loop creation on any thread. The default `asyncio` event loop policy only automatically creates event loops in the main threads. Other threads must create event loops explicitly or `asyncio.get_event_loop` (and therefore `.IOLoop.current`) will fail. Installing this policy allows event loops to be created automatically on any thread, matching the behavior of Tornado versions prior to 5.0 (or 5.0 on Python 2). Usage:: asyncio.set_event_loop_policy(AnyThreadEventLoopPolicy()) .. versionadded:: 5.0 .. deprecated:: 6.2 ``AnyThreadEventLoopPolicy`` affects the implicit creation of an event loop, which is deprecated in Python 3.10 and will be removed in a future version of Python. At that time ``AnyThreadEventLoopPolicy`` will no longer be useful. If you are relying on it, use `asyncio.new_event_loop` or `asyncio.run` explicitly in any non-main threads that need event loops. c<V^8dQhRR/#r1r")rrs"rr:__getattr__..AnyThreadEventLoopPolicy.__annotate__s  $ rc^<\SV`4\P!R\^R7R#)zYAnyThreadEventLoopPolicy is deprecated, use asyncio.run or asyncio.new_event_loop instead) stacklevelN)rY__init__rrr)r$r\s&rr 6__getattr__..AnyThreadEventLoopPolicy.__init__s% " 8& rc4<V^8dQhRS[P/#rrErF)rrs"rrrs  (A(A rc<\SV`4# \d'TP4pTP T4Tu#i;ir!)rYrrXrr)r$r>r\s& rr<__getattr__..AnyThreadEventLoopPolicy.get_event_loopsF  7133# ..0D''-K  s .AAr") r'r(r)r*rr rr+r,rrs@@rrrs# 4     r) rr'_AnyThreadEventLoopPolicysysplatformrKrErDefaultEventLoopPolicy)r _BasePolicyrs& r __getattr__rs  ))wxl2DTHMNN!( <<7 "w 5( ( "@@K!88K+ {+ Z%=! $$rca]tRtRtoRtRtV3RlRltV3RlRltV3RlR ltV3R lR lt V3R lR lt V3RlRlt V3RlRlt V3RlRlt V3RlRltV3RlRltV3RlRltV3RlRltV3RlRltRtVtR#) SelectorThreadiaYDefine ``add_reader`` methods to be called in a background select thread. Instances of this class start a second thread to run a selector. This thread is completely hidden from the user; all callbacks are run on the wrapped event loop's thread. Typically used via ``AddThreadSelectorEventLoop``, but can be attached to a running asyncio loop. Fc8<V^8dQhRS[PRR/#r real_looprNr )rrs"rrSelectorThread.__annotate__s!#<#<'";";#<#.__annotate__s : :D :rcX<"SPP4GRjxL R#L5ir!)_thread_manager_handle __anext__r#srthread_manager_anext5SelectorThread.__init__..thread_manager_anexts --779 9 9s *(*cD<SPPS!44#r!) _real_loop create_task)r$r!sr)SelectorThread.__init__..sDOO//0D0FGrcontext) contextvars copy_context_main_thread_ctxr$ threading Conditionr5 _select_argsr6r;_thread_managerrr_readers_writerssocket socketpair_waker_rr8 setblockingr4rvrt_consume_waker)r$rr!sf&@rr SelectorThread.__init__s + 8 8 :#%//1  "'37 &*&:&:&<# : : !! G)) " >@ =? (.'8'8':$ t} !!%( !!%(D!  t':':;rc<V^8dQhRR/#r1r")rrs"rrrs  t rcVP'dR#VP;_uu_4RVnVPP4RRR4VP 4VP eVP P 4\PV4VPVP4VPP4VPP4RVnR# +'giL;ir) _closedr5r6r7_wake_selectorr;r<r4discardrr5rgr8r#s&rrgSelectorThread.closes <<<     %)D "    $ $ &  << # LL   % 4==)    s "C88 D cB<V^8dQhRS[PR,/#)rr)NN)rAsyncGenerator)rrs"rrrsv'<'<V^8dQhRS[RS[R,RS[RR/#rrhrNrrrorgrr)rrs"rrr2%19)1DMP rcp\P!V.VO5!VPV&VP4R#r!)rrr1r<r$rhrrs&&&*rrtSelectorThread.add_reader.&--h>> b rc><V^8dQhRS[RS[R,RS[RR/#rrrs)rrs"rrrrtrcp\P!V.VO5!VPV&VP4R#r!)rrr2r<rvs&&&*rrxSelectorThread.add_writerrxrc&<V^8dQhRS[RS[/#rrhrrgrb)rrs"rrr 3rcfVPVTP4R# \dR#i;iFT)r1rVr<r$rhs&&rrSelectorThread.remove_reader8  b!    ! 00c&<V^8dQhRS[RS[/#r}r~)rrs"rrrrrcfVPVTP4R# \dR#i;ir)r2rVr<rs&&rrSelectorThread.remove_writerrr) r;r6r,r1r$r/r5r;rr5r8r2N)r'r(r)r*rr;r rgr0r<r7rFrEr]rirtrxrrr+r,r-s@rrrsG#<#