g ddlmZddlZddlZddlZddlZddlmZmZm Z m Z ddl m Z edZ e dZejdk\r ej Zn d dZd d Zy) ) annotationsN)AnyTypeVarCallable Awaitable) ParamSpecT_Retval T_ParamSpec) cKtjj}tj}t j |j|g|i|}|jd|d{S7w)aAsynchronously 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 H/var/www/openai/venv/lib/python3.12/site-packages/openai/_utils/_sync.py to_threadrsa~~..0&&(%%cggtEdEfE ))$ ::::sA,A5.A3/A5cdfd }|S)aO 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>Ktg|i|d{S7w)N)r)rrfunctions rwrapperzasyncify..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(rr/sv" 44' :  & v!!I;-;9I;Ug; ;& r(