
    yg/                       d dl m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mZ ddlmZ ddlmZmZmZmZmZ dd	lmZmZ dd
lmZ ddlmZmZ ddlm Z m!Z! ddl"m#Z#m$Z$ ddl%m&Z& ddl'm(Z( ddl)m*Z* ddgZ+ G d de           Z, G d de!          Z- G d d          Z. G d d          Z/ G d d          Z0 G d d          Z1dS )    )annotationsN)ListUnionIterablecast)Literal   )_legacy_response)embedding_create_params)	NOT_GIVENBodyQueryHeadersNotGiven)is_givenmaybe_transform)cached_property)numpy	has_numpy)SyncAPIResourceAsyncAPIResource)to_streamed_response_wrapper"async_to_streamed_response_wrapper)make_request_options)EmbeddingModel)CreateEmbeddingResponse
EmbeddingsAsyncEmbeddingsc                  X    e Zd Zedd            Zedd            ZeeedddedddZdS )r   returnEmbeddingsWithRawResponsec                     t          |           S a  
        This property can be used as a prefix for any HTTP method call to return
        the raw response object instead of the parsed content.

        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
        )r!   selfs    V/var/www/html/nourish/venv/lib/python3.11/site-packages/openai/resources/embeddings.pywith_raw_responsezEmbeddings.with_raw_response   s     )...    EmbeddingsWithStreamingResponsec                     t          |           S z
        An alternative to `.with_raw_response` that doesn't eagerly read the response body.

        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
        )r)   r$   s    r&   with_streaming_responsez"Embeddings.with_streaming_response&   s     /t444r(   N
dimensionsencoding_formatuserextra_headersextra_query
extra_bodytimeoutinput=Union[str, List[str], Iterable[int], Iterable[Iterable[int]]]modelUnion[str, EmbeddingModel]r.   int | NotGivenr/   %Literal['float', 'base64'] | NotGivenr0   str | NotGivenr1   Headers | Noner2   Query | Noner3   Body | Noner4   'float | httpx.Timeout | None | NotGivenr   c       	            ||||d}
t                    sd|
d<   dfd}|                     dt          |
t          j                  t          ||||	|	          t          
          S )c  
        Creates an embedding vector representing the input text.

        Args:
          input: Input text to embed, encoded as a string or array of tokens. To embed multiple
              inputs in a single request, pass an array of strings or array of token arrays.
              The input must not exceed the max input tokens for the model (8192 tokens for
              `text-embedding-ada-002`), cannot be an empty string, and any array must be 2048
              dimensions or less.
              [Example Python code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken)
              for counting tokens. Some models may also impose a limit on total number of
              tokens summed across inputs.

          model: ID of the model to use. You can use the
              [List models](https://platform.openai.com/docs/api-reference/models/list) API to
              see all of your available models, or see our
              [Model overview](https://platform.openai.com/docs/models) for descriptions of
              them.

          dimensions: The number of dimensions the resulting output embeddings should have. Only
              supported in `text-embedding-3` and later models.

          encoding_format: The format to return the embeddings in. Can be either `float` or
              [`base64`](https://pypi.org/project/pybase64/).

          user: A unique identifier representing your end-user, which can help OpenAI to monitor
              and detect abuse.
              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).

          extra_headers: Send extra headers

          extra_query: Add additional query parameters to the request

          extra_body: Add additional JSON properties to the request

          timeout: Override the client-level default timeout for this request, in seconds
        r5   r7   r0   r.   r/   base64r/   objr   r    c                   t                    r| S | j        D ]}t          t          |j                  }t          |t                    s2t                      s?t          j        dt          j
        |                                                    |_        t          j        t          j
        |          d                                          |_        | S Nffloat32)dtyper   datar   object	embedding
isinstancestrr   arrayrC   	b64decodetolistnp
frombufferrD   rM   rK   r/   s      r&   parserz!Embeddings.create.<locals>.parserm       (( 
 X 
 
	FI$788!$,,  {{ */+c6;KD;Q;Q*R*R*Y*Y*[*[I''*,-(..i+ + +fhh '' Jr(   /embeddingsr1   r2   r3   r4   post_parserbodyoptionscast_torD   r   r    r   r   _postr   r   EmbeddingCreateParamsr   r   r%   r5   r7   r.   r/   r0   r1   r2   r3   r4   paramsrV   s       `       r&   createzEmbeddings.create/   s    j $.
 
 (( 	1(0F$%	 	 	 	 	 	& zz )@)VWW(+'%"   ,  
 
 	
r(   )r    r!   )r    r)   r5   r6   r7   r8   r.   r9   r/   r:   r0   r;   r1   r<   r2   r=   r3   r>   r4   r?   r    r   __name__
__module____qualname__r   r'   r,   r   re    r(   r&   r   r      s        / / / _/ 5 5 5 _5 &/AJ( )-$("&;D\
 \
 \
 \
 \
 \
 \
 \
r(   c                  X    e Zd Zedd            Zedd            ZeeedddedddZdS )r   r    AsyncEmbeddingsWithRawResponsec                     t          |           S r#   )rm   r$   s    r&   r'   z!AsyncEmbeddings.with_raw_response   s     .d333r(   $AsyncEmbeddingsWithStreamingResponsec                     t          |           S r+   )ro   r$   s    r&   r,   z'AsyncEmbeddings.with_streaming_response   s     4D999r(   Nr-   r5   r6   r7   r8   r.   r9   r/   r:   r0   r;   r1   r<   r2   r=   r3   r>   r4   r?   r   c       	           K   ||||d}
t                    sd|
d<   dfd}|                     dt          |
t          j                  t          ||||	|	          t          
           d{V S )rA   rB   rC   r/   rD   r   r    c                   t                    r| S | j        D ]}t          t          |j                  }t          |t                    s2t                      s?t          j        dt          j
        |                                                    |_        t          j        t          j
        |          d                                          |_        | S rF   rJ   rU   s      r&   rV   z&AsyncEmbeddings.create.<locals>.parser   rW   r(   rX   rY   r[   Nr_   r`   rc   s       `       r&   re   zAsyncEmbeddings.create   s      j $.
 
 (( 	1(0F$%	 	 	 	 	 	& ZZ )@)VWW(+'%"   ,   
 
 
 
 
 
 
 
 	
r(   )r    rm   )r    ro   rf   rg   rk   r(   r&   r   r      s        4 4 4 _4 : : : _: &/AJ( )-$("&;D\
 \
 \
 \
 \
 \
 \
 \
r(   c                      e Zd ZddZdS )r!   
embeddingsr   r    Nonec                P    || _         t          j        |j                  | _        d S N)_embeddingsr
   to_raw_response_wrapperre   r%   rt   s     r&   __init__z"EmbeddingsWithRawResponse.__init__  s(    %&>
 
r(   Nrt   r   r    ru   rh   ri   rj   r{   rk   r(   r&   r!   r!     (        
 
 
 
 
 
r(   r!   c                      e Zd ZddZdS )rm   rt   r   r    ru   c                P    || _         t          j        |j                  | _        d S rw   )rx   r
   async_to_raw_response_wrapperre   rz   s     r&   r{   z'AsyncEmbeddingsWithRawResponse.__init__  s(    %&D
 
r(   Nrt   r   r    ru   r}   rk   r(   r&   rm   rm   
  r~   r(   rm   c                      e Zd ZddZdS )r)   rt   r   r    ru   c                F    || _         t          |j                  | _        d S rw   )rx   r   re   rz   s     r&   r{   z(EmbeddingsWithStreamingResponse.__init__  s%    %2
 
r(   Nr|   r}   rk   r(   r&   r)   r)     r~   r(   r)   c                      e Zd ZddZdS )ro   rt   r   r    ru   c                F    || _         t          |j                  | _        d S rw   )rx   r   re   rz   s     r&   r{   z-AsyncEmbeddingsWithStreamingResponse.__init__  s%    %8
 
r(   Nr   r}   rk   r(   r&   ro   ro     r~   r(   ro   )2
__future__r   rP   rC   typingr   r   r   r   typing_extensionsr   httpx r
   typesr   _typesr   r   r   r   r   _utilsr   r   _compatr   _extrasr   rS   r   	_resourcer   r   	_responser   r   _base_clientr   types.embedding_modelr   types.create_embedding_responser   __all__r   r   r!   rm   r)   ro   rk   r(   r&   <module>r      s|   # " " " " "   . . . . . . . . . . . . % % % % % %        + + + + + + > > > > > > > > > > > > > > . . . . . . . . % % % % % % , , , , , , , , 9 9 9 9 9 9 9 9 X X X X X X X X / / / / / / 2 2 2 2 2 2 E E E E E E*
+p
 p
 p
 p
 p
 p
 p
 p
fp
 p
 p
 p
 p
& p
 p
 p
f
 
 
 
 
 
 
 

 
 
 
 
 
 
 

 
 
 
 
 
 
 

 
 
 
 
 
 
 
 
 
r(   