
    hY%h.                        d dl mZ d dlZd dlZd dlZd dlZd dlmZmZm	Z	m
Z
 d dlmZ d dlZd dlZd dlZ ed      Z ed      Zej$                  dk\  rej&                  Zn	 	 	 	 	 	 	 	 ddZ	 	 	 	 	 	 	 	 dd	Zdd
Zy)    )annotationsN)AnyTypeVarCallable	Awaitable)	ParamSpecT_RetvalT_ParamSpec)   	   c                  K   t         j                  j                         }t        j                         }t        j                  |j                  | g|i |}|j                  d|       d{   S 7 w)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eventsget_running_loopcontextvarscopy_context	functoolspartialrunrun_in_executor)funcargskwargsloopctx	func_calls         i/var/www/pru.catia.catastroantioquia-mas.com/valormas/lib/python3.12/site-packages/openai/_utils/_sync.py_asyncio_to_threadr      sa      ~~..0&&(%%cggtEdEfE	))$	::::s   A,A5.A3/A5c                  K   t        j                         dk(  rt        | g|i | d {   S t        j                  j                  t        j                  | g|i |       d {   S 7 B7 w)Nr   )sniffiocurrent_async_libraryr   anyio	to_threadrun_syncr   r   )r   r   r   s      r   r#   r#   )   sp      $$&)3'>t>v>>>))$000   ?s!   *A3A/=A3*A1+A31A3c                     d fd}|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.
    c                 >   K   t        g| i | d {   S 7 w)N)r#   )r   r   functions     r   wrapperzasyncify.<locals>.wrapperS   s"     x9$9&9999s   )r   T_ParamSpec.argsr   T_ParamSpec.kwargsreturnr	    )r'   r(   s   ` r   asyncifyr-   5   s    <: N    )r   Callable[T_ParamSpec, T_Retval]r   r)   r   r*   r+   r   )r   r/   r   r)   r   r*   r+   r	   )r'   r/   r+   z*Callable[T_ParamSpec, Awaitable[T_Retval]])
__future__r   sysr   r   r   typingr   r   r   r   typing_extensionsr   r"   r    anyio.to_threadr	   r
   version_infor#   r   r-   r,   r.   r   <module>r6      s    " 
    4 4 '   :& v **;-;9I;Ug;	;$
)5EQc!r.   