o ;iw @s^UddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZmZmZmZmZddlmZddlmZddl mZmZmZmZmZmZmZddlZddlmZddl m!Z!ddl"m#Z#dd l$m%Z%m&Z&dd l'm(Z(dd l)m*Z*d d l+m,Z,m-Z-ddl.m.Z.edZ/e%dZ0edZ1ej2dkre3e4de5dede6e7e5ffddZ8eGdddZ9ddZ:de j;fddZe=d!Z?dd"d#Z@dZAeeBeCd$<dd%dd d&d'd(d)ZDGd*d+d+ZEd,d-ZFGd.d/d/ee/ZG 1dd2eejHeGffd3d4ZIGd5d6d6ZJe@eJZKGd7d8d8eJZLdd9ee5fd:d;ZMdd?ZOGd@dAdAZPgZQdBdCZRdDee0e/fdee0e jNdde/fffdEdFZSdGee/dee/dffdHdIZTedJdKZUe dLZVe dMZWdNedOe jeVeWfde jXeVeWdffdPdQZYGdRdSdSe je/ZZdTeee/ee/fdee/dffdUdVZ[e j\dWee/dfdXee1dfdee6e/e1fdffdYdZZ]e j\d[ee/dfdee6e/d\fdffd]dZZ]d^dZZ]eGd_d`d`e je/Z^eGdadbdbZ_GdcddddZ`e`Zadedfd[ee/dfdgebdee/dffdhdiZcdjegee/fdee/dffdkdlZddmdnZedodpZf eddqee/dfdree/gee1fdseBdgebdee1dff dtduZg ddqee/dfdree/gee1fdseBdveeBdee1dff dwdxZhd[ee/dfdee/dffdydzZid{e6eBeBeBfd|e5fd}d~ZjdS)N)AsyncGenerator AsyncIterable AwaitableIterableIterator)asynccontextmanager) dataclass)AnyCallableGenericOptionalTypeVarUnioncast)Runner) MethodWithAio)NestedEventLoops) ParamSpec assert_type)is_interactive_ipythondeprecation_warning)AsyncUsageWarning InvalidError)loggerTPVwin32 code_line original_funcreturnc Cs`ddl}|j}t|}|dkr |dr |ddd}d|fS|dkr4|d r4|d d d}d|fS|d krj|d |}|rb|\}}} d |d|d| d|d|d| d }d|fSdd|dfS|dkr|d|} | r| \}}d |d|d|d|d }d|fSdd|dfS|r|drd| |d} | | |} | r|ddd}d|fSd| |d} | | |}|rd}|d|}|rt | d}|d|}||d}|d | }d|fSd| |d!}| ||}|sdd|dfSgd"}|D]}| d#|d#|r/dd|dfSq|}|}|d}|dkrj||}|sS|d$ksS|d%krZ|}|d8}n |rd|d8}nn|dks@|d|}||d}|d&|}|rt | d}|d||}|||d}|jd'| |d(d)|dd*}|d |}d|fS)+a Rewrite a blocking call to use async/await syntax. Handles four patterns: 1. __aiter__: for x in obj -> async for x in obj 2. __aenter__: with obj as x -> async with obj as x 3. Async generators in for loops: for x in obj.method(...) -> async for x in obj.method(...) 4. Regular methods: obj.method() -> await obj.method.aio() Args: code_line: The line of code containing the blocking call original_func: The original function object being called Returns: A tuple of (success, rewritten_code): - success: True if the pattern was found and rewritten, False if falling back to generic - rewritten_code: The rewritten code or a generic suggestion rN __aiter__zfor z async for rT __aenter__zwith z async with __setitem__z(\w+)\[([^\]]+)\]\s*=\s*(.+)zYou can't use `[z] = z@` syntax asynchronously - there may be an alternative api, e.g. z .put.aio(z, )Fz await ...z .aio(...) __getitem__z(\w+)\[([^\]]+)\]$zA]` syntax asynchronously - there may be an alternative api, e.g. z .get.aio(z(for\s+\w+\s+in\s+.*\.)z(\s*\()z\.z (?!\s*\()z'^(\s*(?:\w+\s*=|return|yield|raise)\s+)zawait z\s*\() ifelifwhileandornotinisforz\b_.z^(return|yield|raise)\s+z(\.z)\s*\(z\1.aio()count)re__name__inspectisasyncgenfunction startswithreplacematchstripgroupsescapesearchlengrouplstripstartisalnumisspacesub) r!r"r6 func_name is_async_gen suggestion setitem_matchobjkeyvalue getitem_match for_pattern for_matchproperty_patternproperty_matchstatement_start prefix_match before_expr after_prefixmethod_pattern method_matchunsafe_keywordskeyword method_start expr_startic before_obj obj_and_rest keyword_match keyword_lenrewritten_exprreL/home/ubuntu/.local/lib/python3.10/site-packages/modal/_utils/async_utils.pyrewrite_sync_to_async0s                 rgc@s.eZdZUdZeed<eed<eeed<dS) _CallFramez0Simple dataclass to hold call frame information.filenamelinenolineN)r7 __module__ __qualname____doc__str__annotations__intr rerererfrhs rhcCsddl}ddl}t}|jt}|D]:}|j}|jjd|jj|vs9|jjd|jj|vs9|j||kr:q| ||j }t ||j |rI|nddSdS)z Extract the call frame from user code by filtering out frames from synchronicity and asyncio. Returns a _CallFrame with the filename, line number, and source line, or None if not found. rN synchronicityasyncio)rirjrk) linecacheosr8stackpathabspath__file__risepgetlinerjrh)rtrurv this_file frame_inforirkrererf_extract_user_call_frames r~c CstrdSddl}|rt|dt|}|dvrdSt}gd}d}d}|r7|r7|jr7|j}t||\}}|rD|rD|d|d|rdt j t j |j d}|jd|t|j |j|ddS|d|tdS) Nrr7) __aexit__ __anext__)z=A blocking Modal interface is being used in an async context.z, This may cause performance issues or bugs.z4 Consider rewriting to use Modal's async interfaces:z# https://modal.com/docs/guide/asyncz Suggested rewrite: z Original line:)rirjmodule)rwarningsgetattrror~rkr=rgappendrurwsplitextbasenameri warn_explicitjoinrrjwarn) r"rrH call_frame message_partsrJr!r3 module_namerererf_blocking_in_async_warnings4   rcCsLddlm}|ds dSzt|WdStyty%YdSw)aD Safety wrapper around _blocking_in_async_warning to ensure it never raises exceptions. This is non-critical functionality (just a warning), so we don't want it to break user code. However, if the warning has been configured to be treated as an error (via filterwarnings), we should let that propagate. r)configasync_warningsN)rgetrr Exception)r"rrererf_safe_blocking_in_async_warning.s    r)blocking_in_async_callbackcCsZt|s t|r|jd}n t|trd|j}nd}|dur%|j}tj |||dS)Nr3 _BLOCKING_) target_module) r8isclass isfunctionr7rC isinstancer rl synchronizercreate_blocking)rLr blocking_namerererfsynchronize_apiHs  rRETRY_N_ATTEMPTS_OVERRIDEZ) n_attempts base_delay delay_factortimeoutcs&fdd}|dur||S|S)aDecorator that calls an async function multiple times, with a given timeout. If a `base_delay` is provided, the function is given an exponentially increasing delay on each run, up until the maximum number of attempts. Usage: ``` @retry async def may_fail_default(): # ... pass @retry(n_attempts=5, base_delay=1) async def may_fail_delay(): # ... pass ``` cs"tfdd}|S)Ncstdurt}n}}t|D]l}t}ztj|i|dIdHWStjy:tddtyo}z*||dkrHtdd|dt|d|d ||dd WYd}~nd}~wwt |IdH|9}qdS) Nrz Function z was cancelledrzFailed invoking function z: z (took z s, sleeping z s and trying z more times)) rrangetimerswait_forCancelledErrorrdebugrsleep)argskwargslocal_n_attemptsdelayr^t0e)rrfnrrrerf f_wrappedns: $    z+retry..decorator..f_wrapped) functoolswraps)rrrrrr)rrf decoratormszretry..decoratorNre) direct_fnrrrrrrerrfretryXsrc @seZdZUdZeejed<d"dddee de fdd Z d d Z e d e fd dZddZddZddZd ejfddZ d#dee de de d ejfddZeded efd d!ZdS)$ TaskContexta{A structured group that helps manage stray tasks. This differs from the standard library `asyncio.TaskGroup` in that it *cancels* tasks still running after exiting the context manager, rather than waiting for them to finish. Arguments: `grace: float`: period in seconds, which will wait for a certain amount of time before cancelling all remaining tasks. This is useful for allowing tasks to finish after the context exits. `cancellation_grace: float = 1.0`: period in seconds that cancelled tasks are allowed to stall before they exit once they get cancelled (e.g. if they do async handling of the CancelledError). If tasks take longer than this to exit the tasks are left dangling when the context exits. Usage: ```python notest async with TaskContext(grace=1.0) as task_context: task = task_context.create_task(coro()) ``` _loopsNg?)cancellation_gracegracercCs||_||_t|_dSN)_grace_cancellation_gracesetr)selfrrrererf__init__s zTaskContext.__init__cst|_t|_dSr)r_tasksrsEvent_exitedrrererfrDszTaskContext.startr#cC |jSr)ris_setrrererfexiteds zTaskContext.exitedcs|IdH|Sr)rDrrererfr%szTaskContext.__aenter__cs||jtdIdHdd|jD}d}zz|jdur4|r4tj|ddi}tj||jdIdHWn tjy?YnwW|r^t tj  |IdHWdn1sYwYg}|jD])}| rt t  |Wdn1s}wYqc|||qctj|ddi}z tj||jdIdHWntjytd|YnwtdIdHdS|rt tj  |IdHWdn1swYg}|jD]*}| rt t  |Wdn1swYq|||qtj|ddi}z tj||jdIdHWntjy4td|YnwtdIdHw) agThis is called when exiting the TaskContext Two important properties that we need to maintain here: * Should never raise exceptions as a result of exceptions (incl. cancellations) in the contained tasks * Should not have an open-ended runtime, even if the contained tasks are uncooperative with cancellations. rNcSg|]}|s|qSredone.0trererf z$TaskContext.stop..return_exceptionsTrz;Internal warning: Tasks did not cancel in a timely manner: )rrrsrrrgatherr TimeoutError contextlibsuppressrr BaseExceptionresultcancelrrrr)runfinished_tasks gather_futurecancelled_taskstaskcancellation_gatherrererfstopsl            zTaskContext.stopc sxt|}z t|IdHWdStjy;|s:ttj |IdHWd1s5wYw)a This is a bit involved: * If there is an exception within the "context", we typically always want to reraise that * If a cancellation comes in *during* aexit/stop execution itself, we don't actually cancel the exit logic (it's already performing cancellation logic of sorts), but we do reraise the CancelledError to prevent muting cancellation chains N)rs ensure_futurershieldrrrr)rexc_typerNtb stop_taskrererfrs  zTaskContext.__aexit__cCsbt|tjr |}nt|rt}||}n tdt|d|j || |jj |S)NzObject of type z is not a coroutine or Task) rrsTask iscoroutineget_event_loop create_taskrtyperaddadd_done_callbackdiscard)r coro_or_taskrlooprererfrs    zTaskContext.create_taskr Trr log_exceptioncsnttjr jjnjdfdd }|}|dj|| jj |S)Nr#c stdjsfz tjdIdHWn/tyH}z#r3t|tjr3tddn r>t ddWYd}~nd}~wwztjj dIdHWn tjybYq wjr tddS)NzStarting infinite loop rzLoop attempt for z timed outz failedzExiting infinite loop for ) rrrrsrrrrerror exceptionrwait)excasync_f function_namerrrrrerf loop_coros&z,TaskContext.infinite_loop..loop_coroz loop)r#N) rrpartialfuncrmrset_namerrrr)rrrrrrrrerrf infinite_loop s    zTaskContext.infinite_loopcorosc sbt4IdHfdd|D}tj|IdHWdIdHS1IdHs*wYdS)uWait for a sequence of coroutines to finish, concurrently. This is similar to `asyncio.gather()`, but it uses TaskContext to cancel all remaining tasks if one fails with an exception other than `asyncio.CancelledError`. The native `asyncio` function does not cancel remaining tasks in this case, which can lead to surprises. For example, if you use `asyncio.gather(t1, t2, t3)` and t2 raises an exception, then t1 and t3 would continue running. With `TaskContext.gather(t1, t2, t3)`, they are cancelled. It's still useful to use `asyncio.gather()` if you don't need cancellation — for example, if you're just gathering quick coroutines with no side-effects. Or if you're gathering the tasks with `return_exceptions=True`. Usage: ```python notest # Example 1: Await three coroutines created_object, other_work, new_plumbing = await TaskContext.gather( create_my_object(), do_some_other_work(), fix_plumbing(), ) # Example 2: Gather a list of coroutines coros = [a.load() for a in objects] results = await TaskContext.gather(*coros) ``` Ncsg|]}|qSre)r)rcorotcrerfrMz&TaskContext.gather..)rrsr)rtasksrerrfr.s 0zTaskContext.gatherr)rrT)r7rlrmrnrrsrrpr floatrrDpropertyboolrr%rrrr staticmethodrr rrerererfrs. 1  !rcCsHtjjdd}|tj|}|WdS1swYdS)aFairly hacky thing that's needed in some extreme cases. It's basically works like asyncio.run but unlike asyncio.run it also works with in the case an event loop is already running. It does this by basically moving the whole thing to a separate thread. r) max_workersN) concurrentfuturesThreadPoolExecutorsubmitrsrunr)rexecutorfutrererfrun_coro_blockingQs$rc@seZdZdZedZddefddZddZd ed e e d ffd d Z de e d ffddZ de fddZdefddZddZddZd S)TimestampPriorityQueuezW A priority queue that schedules items to be processed at specific timestamps. infrmaxsizecCs&t|_tj|d|_t|_dS)Nr)rs Condition condition PriorityQueue_queue itertoolsr5_counter)rrrererfrds zTimestampPriorityQueue.__init__cs||jdIdHdSr)put _MAX_PRIORITYrrererfclosejszTimestampPriorityQueue.close timestampitemNc sj|j|t|j|fIdH|j4IdH|jWdIdHdS1IdHs.wYdS)zS Add an item to the queue to be processed at a specific timestamp. N)rrnextrr notify_all)rrrrererfrms  .zTimestampPriorityQueue.putr#c s  |j4IdH{|r|jIdH|s|jIdH\}}}t}||kr9|WdIdHS||jkrJ WdIdHdS||}|j|||fztj |j|dIdHWntj yyYWdIdHqwWdIdHn 1IdHswYq)zQ Get the next item from the queue that is ready to be processed. TNr) remptyrrrrr put_nowaitrsrr)rrcounterrnow sleep_timerererfrus2  (zTimestampPriorityQueue.getcCrr)rr"rrererfr" zTimestampPriorityQueue.emptycCrrrqsizerrererfr)r'zTimestampPriorityQueue.qsizecs(|s|IdH|rdSdS)z Clear the retry queue. Used for testing to simulate reading all elements from queue using queue_batch_iterator. N)r"rrrererfclearszTimestampPriorityQueue.clearcCrrr(rrererf__len__r'zTimestampPriorityQueue.__len__)r)r7rlrmrnrrrqrrrrrrrr"r)r*r+rerererfr]s rdQ?qcCsg} |rt|dkr|Vg}t|IdH|IdH}t||kr-|Vg}|dur.decorator..f_wrapped)r7rr)rLrrrKrfrsz4warn_if_generator_is_not_consumed..decoratorre)rrrerNrf!warn_if_generator_is_not_consumeds  rOrnested_async_messagecCsPzt}||WdWS1swYWdSty't|w)aCompatibility function to run an async coroutine in a temporary event loop. This is needed for compatibility with the async implementation of Function.spawn_map. The future plan is to have separate implementations so there is no issue with nested event loops. N)rr rr)rrPrunnerrererf%run_coroutine_in_temporary_event_loops( rRc@s@eZdZdZdejedffddZddZdd Z d d Z dS) AsyncOrSyncIterableaCompatibility class for non-synchronicity wrapped async iterables to get both async and sync interfaces in the same way that synchronicity does (but on the main thread) so they can be "lazily" iterated using either `for _ in x` or `async for _ in x` nested_async_message is raised as an InvalidError if the async variant is called from an already async context, since that would otherwise deadlock the event loop async_iterableNcCs||_||_dSr)_async_iterablerP)rrTrPrererfrr;zAsyncOrSyncIterable.__init__cCs|jSr)rUrrererfr$!szAsyncOrSyncIterable.__aiter__ccs^z!t}t||jEdHWdWdS1swYWdSty.t|jwr)r run_async_genrUrrrP)rrQrererfrG$s&  zAsyncOrSyncIterable.__iter__cs&t|jdr|jIdHdSdS)NrD)hasattrrUrDrrererfrD+s zAsyncOrSyncIterable.aclose) r7rlrmrntypingrr rr$rGrDrerererfrSs  rScs"fdd}tt|dS)Ncs.ztdIdHWIdHIdH)Ng _B)rsrrerrerfwrapper5s  zon_shutdown..wrapper)_shutdown_tasksrrsr)rrZrerYrf on_shutdown3s r\fcs(tdtjdtjffdd }|S)zNConvert a blocking function into one that runs in the current loop's executor.rrcs0t}|dtjg|Ri|IdHSr)rsget_running_looprun_in_executorrr)rrrr]rerfrZBs&zasyncify..wrapper)rrrrr)r]rZrer`rfasyncify?sraiteratorcCsBt}t} |dt||IdH}||urdStt|Vq )z5Iterate over a blocking iterator in an async context.TN)rsr^objectr_r rr)rbrDONErLrererfiterate_blockingJs recOs dVdS)zAsync noop context manager. Note that for Python 3.10+ you can use contextlib.nullcontext() instead. Usage: async with asyncnullcontext(): pass NrerrrererfasyncnullcontextVs rg YIELD_TYPE SEND_TYPErQr5c csd}d} z|r|||}n|||}Wnty*}z|dd}~wty3YdSwz|V}d}WntyO}z|}WYd}~nd}~wwq)z*Convert an async generator into a sync oneN)r rBr<KeyboardInterruptStopAsyncIterationr)rQr5 next_sendr next_yieldrerrrererfrVgs. rVc@s@eZdZdeedffddZdeedffddZdd ZdS) aclosingagenNcCs ||_dSrrp)rrprererfrr'zaclosing.__init__r#cs|jSrrqrrererfr%szaclosing.__aenter__cs|jIdHdSr)rprD)rrrrrererfrszaclosing.__aexit__)r7rlrmrrrr%rrerererfros rorFc Cst|dr=tttdf|}z|2z 3dHW}|Vq6Wt|dr-|IdHdSdSt|dr<|IdHwwt|dsFJdttt|D]}|VqNdS)Nr$rDrGz9sync_or_async_iter requires an Iterable or AsyncGenerator)rWrXrrrrDr)rFrprrererfsync_or_async_iters   rrg1g2cCdSrre)rsrtrererf async_ziprv generators.cGrurre)rxrererfrvrwcsg}z zddfdd|D}tj|IdH}t|VWn ty*YnwqWg}|D]}|s@|||q1z tj|IdHWn tjyUYnwd}|D]+}z |IdHWqZt y}z|durs|}t d|WYd}~qZd}~ww|dur|dSg}|D]}|s|||qz tj|IdHWn tjyYnwd}|D]+}z |IdHWqt y}z|dur|}t d|WYd}~qd}~ww|dur|w)NTcs|IdHSr)r)r5rererf next_itemszasync_zip..next_itemcsg|] }t|qSrersrrr5ryrerfrzasync_zip..Error closing async generator: ) rsrtuplerkrrrrrDrrr)rxritemsrrfirst_exceptionr5rrer|rfrvsz    c@eZdZUeed<dS) ValueWrapperrNN)r7rlrmrrprerererfr rc@r)ExceptionWrapperrNN)r7rlrmrrprerererfrrrc@s eZdZdS)StopSentinelTypeN)r7rlrmrerererfrs r$@)cancellation_timeoutrc stjt|dddttdfffdd fdd|D}t}z|rqtjg||tjd IdH\}}||vr]| }t |t rN|j Vnt |t|j t}||@}||8}|D]}|IdHqg|s+s|IdH}t |t r|j Vnt |t|j t}ruWd d ||hBD} | D]} | qztjttj| d d i|dIdHWdStjytdYdSwd d ||hBD} | D]} | qztjttj| d d i|dIdHWwtjy tdYww)a Asynchronously merges multiple async generators into a single async generator. This function takes multiple async generators and yields their values in the order they are produced. If any generator raises an exception, the exception is propagated. Args: *generators: One or more async generators to be merged. Yields: The values produced by the input async generators. Raises: Exception: If any of the input generators raises an exception, it is propagated. Usage: ```python import asyncio from modal._utils.async_utils import async_merge async def gen1(): yield 1 yield 2 async def gen2(): yield "a" yield "b" async def example(): values = set() async for value in async_merge(gen1(), gen2()): values.add(value) return values # Output could be: {1, "a", 2, "b"} (order may vary) values = asyncio.run(example()) assert values == {1, "a", 2, "b"} ``` rr generatorNc sz7t|4IdH!}|2z3dHW}t|IdHq 6WdIdHWdS1IdHs1wYWdStyU}zt|IdHWYd}~dSd}~wwr)rorrrr)rstreamrr)queuererfproducer s2"zasync_merge..producercsh|] }t|qSrerzr{)rrerf r}zasync_merge..) return_whencSrrerrrererfr9rzasync_merge..rTrz'Timed out while cleaning up async_merge)rsQueuerArrrrrFIRST_COMPLETEDrrrrNrrr"rrrrrrr) rrxrnew_output_taskrr3rfinished_producersfinished_producerrrre)rrrf async_mergest+            r awaitablecCs|IdHVdSrre)rrererfcallable_to_agenIrCrcs\dd|D}z tj|IdHWSty-|D]}|qtj|ddiIdHw)NcSsg|]}t|qSre)rsrrrererfrNrz(gather_cancel_on_exc..rF)rsrrr)coros_or_futures input_tasksrrererfgather_cancel_on_excMs  rcsNt|}z t|IdHWStjy&|r||IdHwr)rsrrr cancelledr)rrrererfprevent_cancellation_abortionXs  rinput_generatorasync_mapper_func concurrencyc stjdddttdfffdd }dttdfffdd ttgfdd tD|Rd |i4IdH}|2z 3dHW}|VqE6WdIdHdS1IdHsawYdS) Nrrr#c st4IdH}|2z3dHW}t|IdHq 6WdIdHn 1IdHs.wYtD] }tIdHq7dSr)rorrr STOP_SENTINEL)rrr3)rrrrerfrps( zasync_map..producercsX IdH}t|trt|jIdH}|Vnt|tr$|jt|tdSqr)rrrrrNrrr)rr2)rrrerfworker}s   zasync_map..workercsg|]}qSrere)rr^)rrerfrszasync_map..r)rsrrrrorr)rrrrrrrre)rrrrrrf async_maphs  * .r buffer_sizec st|p|dtttfdtttfffdd }dttdfffdd }d}i}ttt ||||4IdH4}|2z$3dHW\} } | || <||vrc||V ||=|d7}||vsOq?6WdIdHdS1IdHsvwYdS) Ntupr#cs|d|dIdHfS)Nrrre)r)rrerfmapper_func_wrappersz.async_map_ordered..mapper_func_wrappercs(tD] }IdH|VqdSr)rr5acquire)r^) semaphorererfr$s  z"async_map_ordered..counterrr) rs Semaphorerrqrrrrorrvrelease) rrrrrr$next_idxbufferr output_idx output_itemre)rrrfasync_map_ordereds$&" .rcGszK|D]}|2z 3dHW}|Vq6qWd}|D]+}z |IdHWqtyD}z|dur2|}td|WYd}~qd}~ww|durK|dSd}|D]+}z |IdHWqQty|}z|durj|}td|WYd}~qQd}~ww|dur|w)Nr~)rDrrr)rxr5rrrrererf async_chains@rdeprecation_datereadable_sync_callcsfdd}|S)Ncs:ttr jd}nd}fdd}t|t|dS)NTFcs(tddd|i|S)NzThe async constructor zV.aio(...) will be deprecated in a future version of Modal. Please use zY(...) instead (it doesn't perform any IO, and is safe in async contexts) rrf)rrsync_implementationrerf _async_proxysz7deprecate_aio_usage..deco.._async_proxy)is_classmethod)r classmethod__func__rr)rrrrr)rrfdecos  z!deprecate_aio_usage..decore)rrrrerrfdeprecate_aio_usagesrr)r,r-)r)krsconcurrent.futuresr rrr8rrusysrtypesrXrcollections.abcrrrrrr dataclassesrr r r r r rrrrsynchronicity.async_utilsrsynchronicity.combined_typesrsynchronicity.exceptionsrtyping_extensionsrrmodal._ipythonrmodal._utils.deprecationrrrrrrrrplatformset_event_loop_policyWindowsSelectorEventLoopPolicyrorrrgrhr~ FunctionTyperr Synchronizerrrrrqrprrrrrr3r4%_BlockingWarnIfGeneratorIsNotConsumedrErO CoroutinerRrSr[r\rarergrhri GeneratorrVrorroverloadrvrrrrrrrrrrrrrrerererfs   $       #:   :@ B  (" .      * 8,%   &k    ,   "