U Î~fh. ã@sÆddlmZddlZddlZddlZddlZddlmZmZm Z m Z ddl m Z ddl Z ddlZddlZ edƒZe dƒZejdkrŠejZndd d d d œd d„Zdd d dd œdd„Zdddœdd„ZdS)é)Ú annotationsN)ÚAnyÚTypeVarÚCallableÚ Awaitable)Ú ParamSpecÚT_RetvalÚ T_ParamSpec)éé zCallable[T_ParamSpec, T_Retval]úT_ParamSpec.argsúT_ParamSpec.kwargsr)ÚfuncÚargsÚkwargsÚreturncÏs:tj ¡}t ¡}tj|j|f|ž|Ž}| d|¡IdHS)aŸAsynchronously 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) ÚasyncioÚeventsZget_running_loopÚ contextvarsZ copy_contextÚ functoolsÚpartialÚrunZrun_in_executor)rrrZloopÚctxZ func_call©rú7/tmp/pip-unpacked-wheel-rjiviquo/openai/_utils/_sync.pyÚ_asyncio_to_threads rcÏsBt ¡dkr"t|f|ž|ŽIdHStj tj|f|ž|Ž¡IdHS)Nr)ÚsniffioZcurrent_async_libraryrÚanyioÚ to_threadZrun_syncrr)rrrrrrr)s  ÿrz*Callable[T_ParamSpec, Awaitable[T_Retval]])Úfunctionrcsddddœ‡fdd„ }|S)aP 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. r r r)rrrcŸstˆf|ž|ŽIdHS)N)r)rr©rrrÚwrapperSszasyncify..wrapperr)rr!rr rÚasyncify5sr")Ú __future__rÚsysrrrÚtypingrrrrZtyping_extensionsrrrZanyio.to_threadrr Ú version_inforrr"rrrrÚs