хi SSKJr SSKrSSKrSSKrSSKrSSKJrJrJ r J r SSK J r \"S5r \ "S5r\RS:a \R rO S SjrS S jrg) ) annotationsN)AnyTypeVarCallable Awaitable) ParamSpecT_Retval T_ParamSpec) c# [RR5n[R"5n[ R "URU/UQ70UD6nURSU5IShvN $N7f)aoAsynchronously run function *func* in a separate thread. Any *args and **kwargs supplied for this function are directly passed to *func*. Also, the current :class:`contextvars.Context` is propagated, allowing context variables from the main thread to be accessed in the separate thread. Returns a coroutine that can be awaited to get the eventual result of *func*. N) asyncioeventsget_running_loop contextvars copy_context functoolspartialrunrun_in_executor)funcargskwargsloopctx func_calls M/home/james-whalen/.local/lib/python3.13/site-packages/openai/_utils/_sync.py to_threadrs`~~..0&&(%%cggtEdEfE ))$ ::::sA.A70A51A7c^SU4SjjnU$)a Take a blocking function and create an async one that receives the same positional and keyword arguments. For python version 3.9 and above, it uses asyncio.to_thread to run the function in a separate thread. For python version 3.8, it uses locally defined copy of the asyncio.to_thread function which was introduced in python 3.9. Usage: ```python def blocking_func(arg1, arg2, kwarg1=None): # blocking code return result result = asyncify(blocking_function)(arg1, arg2, kwarg1=value1) ``` ## Arguments `function`: a blocking regular callable (e.g. a function) ## 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. c>># [T/UQ70UD6IShvN $N7f)N)r)rrfunctions rwrapperasyncify..wrapperCs!x9$9&9999s )rT_ParamSpec.argsrT_ParamSpec.kwargsreturnr )r!r"s` rasyncifyr(&s:: N)rCallable[T_ParamSpec, T_Retval]rr$rr%r&r)r!r*r&z*Callable[T_ParamSpec, Awaitable[T_Retval]]) __future__rsysrrrtypingrrrrtyping_extensionsrr r version_inforr(r'r)rr0sv" 44' :  & v!!I;-;9I;Ug; ;& r)