o ;ήc{1 @sddlZddlZddlmZddlmZmZmZmZm Z m Z m Z m Z m Z ejdkr0ddlmZnddlmZddlZddlZddlmZddlmZd*de edfd efd d Ze d Zed Ze dZGdddZeZGdddeZ Gddde eZ!GdddeZd+ddZ"  d,deeeeeeffdede e eefd eeeffddZ# d-deeeeeeffd e$d eeeffd!d"Z%d#dd$d%eeefd&e$d'e ej&d eeeeffd(d)Z'dS).N) import_module) Any AwaitableCallable CoroutineDictGenericOptionalTypeVarUnion) ) ParamSpec) threadlocals) TaskGroup asynclib_namereturncCs@|durt}d|}ztj|WStyt|YSw)Nzanyio._backends._)sniffiocurrent_async_librarysysmodulesKeyErrorr)r modulenamer4/tmp/pip-target-vg8gfxp4/lib/python/asyncer/_main.py get_asynclibs   rT_Retval T_ParamSpecTc@seZdZdefddZdS) PendingTypercCsdS)NAsyncerPendingrselfrrr__repr__/szPendingType.__repr__N)__name__ __module__ __qualname__strr#rrrrr.src@ eZdZdS)PendingValueExceptionNr$r%r&rrrrr)6r)c@s:eZdZd ddZedefddZedefddZdS) SoonValuerNcCs t|_dSN)Pending _stored_valuer!rrr__init__;s zSoonValue.__init__cCst|jtr td|jS)NaThe return value of this task is still pending. Maybe you forgot to access it after the async with asyncer.create_task_group() block. If you need to access values of async tasks inside the same task group, you probably need a different approach, for example with AnyIO Streams.) isinstancer/rr)r!rrrvalue>s zSoonValue.valuecCst|jt Sr-)r1r/rr!rrrreadyJszSoonValue.readyrN) r$r%r&r0propertyrr2boolr3rrrrr,:s   r,c sPeZdZ d deeeefdedeeeeffddZ d fdd Z Z S) rNasync_functionnamercs4tdtjdtjdttffdd }|S)a Create and return a function that when called will start a new task in this task group. Internally it uses the same `task_group.start_soon()` method. But `task_group.soonify()` supports keyword arguments additional to positional arguments and it adds better support for autocompletion and inline errors for the arguments of the function called. Use it like this: ```Python async with asyncer.create_task_group() as task_group: async def do_work(arg1, arg2, kwarg1="", kwarg2="") -> str: # Do work return "Some result value" result = task_group.soonify(do_work)("spam", "ham", kwarg1="a", kwarg2="b") print(result.value) ``` The return value from that function (`result` in the example) is an object `SoonValue`. This `SoonValue` object has an attribute `soon_value.value` that will hold the return value of the original `async_function` *after* the `async with` block. If you try to access the `soon_value.value` inside the `async with` block, before it has the actual return value, it will raise a an exception `asyncer.PendingValueException`. If you think you need to access the return values inside the `async with` block, there's a high chance that you really need a different approach, for example using an AnyIO Stream. But either way, if you have checkpoints inside the `async with` block (you have some `await` there), one or more of the `SoonValue` objects you might have could end up having the result value ready before ending the `async with` block. You can check that with `soon_value.pending`. For example: ```Python async def do_work(name: str) -> str: return f"Hello {name}" async with asyncer.create_task_group() as task_group: result1 = task_group.soonify(do_work)(name="task 1") result2 = task_group.soonify(do_work)(name="task 2") await anyio.sleep(0) if not result1.pending: print(result1.value) if not result2.pending: print(result2.value) ``` ## Arguments `async_function`: an async function to call soon `name`: name of the task, for the purposes of introspection and debugging ## Return A function that takes positional and keyword arguments and when called uses `task_group.start_soon()` to start the task in this task group. That function returns a `SoonValue` object holding the return value of the original function in `soon_value.value`. argskwargsrcsJtjg|Ri|ttdfdd }j|dS)NrcsIdH}|_dSr-)r/)r2 partial_f soon_valuerr value_wrappers  z9TaskGroup.soonify..wrapper..value_wrapper)r8r4) functoolspartialr,wraps start_soon)r9r:r>r7r8r"r;rwrappers z"TaskGroup.soonify..wrapper)r?rArr9r:r,r)r"r7r8rDrrCrsoonifyPsIzTaskGroup.soonifycstIdHS)z:Enter the task group context and allow starting new tasks.N)super __aenter__r! __class__rrrGszTaskGroup.__aenter__r-rr) r$r%r&rrrrobjectr,rErG __classcell__rrrHrrOs [rcCs tj}Gddd|t}|S)a Create a task group used to start multiple concurrent tasks with async functions. `asyncer.create_task_group()` is different from `anyio.create_task_group()` in that it creates an extended `TaskGroup` object that includes the `task_group.soonify()` method. c@r()z,create_task_group..ExtendedTaskGroupNr*rrrrExtendedTaskGroupr+rM)rr) LibTaskGrouprMrrrcreate_task_groupsrOasyncior7backendbackend_optionscs0tdtjdtjdtffdd }|S)a~ Take an async function and create a regular (blocking) function that receives the same keyword and positional arguments for the original async function, and that when called will create an event loop and use it to run the original `async_function` with those arguments. That function returns the return value from the original `async_function`. The current thread must not be already running an event loop. This calls `anyio.run()` underneath. Use it like this: ```Python async def program(name: str) -> str: return f"Hello {name}" result = asyncer.runnify(program)(name="World") print(result) ``` ## Arguments `async_function`: an async function to call `backend` name of the asynchronous event loop implementation - currently either `asyncio` or `trio` `backend_options` keyword arguments to call the backend `run()` implementation with ## Return The return value of the async function ## Raises `RuntimeError`: if an asynchronous event loop is already running in this thread `LookupError`: if the named backend is not found r9r:rcs(tjg|Ri|}tj|dS)N)rQrR)r?r@anyiorunr9r:r<r7rQrRrrrDszrunnify..wrapperr?rArr9r:r)r7rQrRrDrrVrrunnifys.$rXTraise_sync_errorcs.tdtjdtjdtffdd }|S)a# Take an async function and create a regular one that receives the same keyword and positional arguments, and that when called, calls the original async function in the main async loop from the worker thread using `anyio.to_thread.run()`. By default this is expected to be used from a worker thread. For example inside some function passed to `asyncify()`. But if you set `check_called_from_async` to `False`, you can also use this function in a non-async context: without an async event loop. For example, from a blocking/regular function called at the top level of a Python file. In that case, if it is not being called from inside a worker thread started from an async context (e.g. this is not called from a function that was called with `asyncify()`) it will run `async_function` in a new async event loop with `anyio.run()`. This functionality with `check_called_from_async` is there only to allow using `syncify()` in codebases that are used by async code in some cases and by blocking code in others. For example, during migrations from blocking code to async code. Internally, `asyncer.syncify()` uses the same `anyio.from_thread.run()`, but it supports keyword arguments additional to positional arguments and it adds better support for tooling (e.g. editor autocompletion and inline errors) for the arguments and return value of the function. Use it like this: ```Python async def do_work(arg1, arg2, kwarg1="", kwarg2=""): # Do work result = from_thread.syncify(do_work)("spam", "ham", kwarg1="a", kwarg2="b") ``` ## Arguments `async_function`: an async function to be called in the main thread, in the async event loop `check_called_from_async`: If set to `False` ## Return A regular blocking function that takes the same positional and keyword arguments as the original async one, that when called runs the same original function in the main async loop when called from a worker thread and returns the result. r9r:rcsJttdd}tjg|Ri|}|durdurt|Stj|S)Ncurrent_async_moduleF)getattrrr?r@rSrT from_thread)r9r:rZr<r7rYrrrD)s   zsyncify..wrapperrW)r7rYrDrr]rsyncifys2"r^F cancellablelimiterfunctionr`racs&dtjdtjdtffdd }|S)a Take a blocking function and create an async one that receives the same positional and keyword arguments, and that when called, calls the original function in a worker thread using `anyio.to_thread.run_sync()`. Internally, `asyncer.asyncify()` uses the same `anyio.to_thread.run_sync()`, but it supports keyword arguments additional to positional arguments and it adds better support for autocompletion and inline errors for the arguments of the function called and the return value. If the `cancellable` option is enabled and the task waiting for its completion is cancelled, the thread will still run its course but its return value (or any raised exception) will be ignored. Use it like this: ```Python def do_work(arg1, arg2, kwarg1="", kwarg2="") -> str: # Do work return "Some result" result = await to_thread.asyncify(do_work)("spam", "ham", kwarg1="a", kwarg2="b") print(result) ``` ## Arguments `function`: a blocking regular callable (e.g. a function) `cancellable`: `True` to allow cancellation of the operation `limiter`: capacity limiter to use to limit the total amount of threads running (if omitted, the default limiter is used) ## Return An async function that takes the same positional and keyword arguments as the original one, that when called runs the same original function in a thread worker and returns the result. r9r:rcs2tjg|Ri|}tjj|dIdHS)Nr_)r?r@rS to_threadrun_syncrUr`rbrarrrDbs  zasyncify..wrapper)rr9r:r)rbr`rarDrrerasyncify4s.rfr-rJ)rPN)T)(r?r importlibrtypingrrrrrrr r r version_infortyping_extensionsrSranyio._core._eventloopr anyio.abcr _TaskGroupr'rrrrrr. Exceptionr)r,rOrXr6r^CapacityLimiterrfrrrrsf ,      a  9  @