
    3fix                    L   d Z ddlmZ ddlZddlZddlmZmZmZm	Z	m
Z
 ddlmZmZ ddlZddlZddlmZmZ ddlmZ ddlmZmZmZ dd	lmZ dd
lmZmZmZ ddlm Z m!Z!m"Z"m#Z# ddl$m%Z%  ejL                  e'      Z(	 	 	 	 	 	 	 	 ddZ)	 	 	 	 ddZ* G d de      Z+ G d de+      Z,y)zQBase classes for OpenAI large language models. Chat models are in `chat_models/`.    )annotationsN)AsyncIteratorCallable
CollectionIteratorMapping)AnyLiteral)AsyncCallbackManagerForLLMRunCallbackManagerForLLMRun)BaseLLM)
GenerationGenerationChunk	LLMResult)get_pydantic_field_names)_build_model_kwargsfrom_envsecret_from_env)
ConfigDictField	SecretStrmodel_validator)Selfc                    | j                  |d         }|D ]%  }||vr|d   |   ||<   ||xx   |d   |   z  cc<   ' y)zUpdate token usage.usageN)intersection)keysresponsetoken_usage_keys_to_use_keys        X/var/www/auto_recruiter/arenv/lib/python3.12/site-packages/langchain_openai/llms/base.py_update_token_usager#      s^     $$Xg%67L 9{" ( 1$ 7K'!24!88	9    c                    | d   st        d      S t        | d   d   d   xs d| d   d   j                  dd      | d   d   j                  dd      d	
      S )z0Convert a stream response to a generation chunk.choices )textr   r(   finish_reasonNlogprobsr)   r*   r(   generation_info)r   get)stream_responses    r"   $_stream_response_to_generation_chunkr0   &   su     9%B''Y'*628b,Y7:>>PTU'	21599*dK
 r$   c                  d    e Zd ZU dZ edd      Zded<    edd      Zded<    edd	
      Zded<   	 dZ	ded<   	 dZ
ded<   	 dZded<   	 dZded<   	 dZded<   	 dZded<   	 dZded<   	  ee      Zded<   	  ed edd             Zd!ed"<   	  ed# ed$d             Zd%ed&<   	  ed' ed(d)gd             Zd%ed*<   	  e ed+d            Zd%ed,<   d-Zded.<   	  edd/
      Zd0ed1<   	 dZd2ed3<   	 d4Zded5<   	 dZd6ed7<   	 dZd6ed8<   	 d9Zd:ed;<   	  e       Z d<ed=<   	 d>Z!d?ed@<   	 dZ"d%edA<   	 dZ#dBedC<   dZ$dDedE<   dZ%dFedG<   	 dZ&dFedH<   	 dZ'dIedJ<   	  e(dK      Z) e*dLM      e+d`dN              Z, e*dOM      dadP       Z-e.dbdQ       Z/	 	 dc	 	 	 	 	 	 	 	 	 dddRZ0	 	 dc	 	 	 	 	 	 	 	 	 dedSZ1	 	 dc	 	 	 	 	 	 	 	 	 dfdTZ2	 	 dc	 	 	 	 	 	 	 	 	 dgdUZ3	 dh	 	 	 	 	 	 	 didVZ4ddW	 	 	 	 	 	 	 	 	 	 	 djdXZ5e.dbdY       Z6e.dkdZ       Z7e.dld[       Z8dm fd\Z9e:dnd]       Z;e.dod^       Z<dpd_Z= xZ>S )q
BaseOpenAIuG  Base OpenAI large language model class.

    Setup:
        Install `langchain-openai` and set environment variable `OPENAI_API_KEY`.

        ```bash
        pip install -U langchain-openai
        export OPENAI_API_KEY="your-api-key"
        ```

    Key init args — completion params:
        model_name:
            Name of OpenAI model to use.
        temperature:
            Sampling temperature.
        max_tokens:
            Max number of tokens to generate.
        top_p:
            Total probability mass of tokens to consider at each step.
        frequency_penalty:
            Penalizes repeated tokens according to frequency.
        presence_penalty:
            Penalizes repeated tokens.
        n:
            How many completions to generate for each prompt.
        best_of:
            Generates best_of completions server-side and returns the "best".
        logit_bias:
            Adjust the probability of specific tokens being generated.
        seed:
            Seed for generation.
        logprobs:
            Include the log probabilities on the logprobs most likely output tokens.
        streaming:
            Whether to stream the results or not.

    Key init args — client params:
        openai_api_key:
            OpenAI API key. If not passed in will be read from env var
            `OPENAI_API_KEY`.
        openai_api_base:
            Base URL path for API requests, leave blank if not using a proxy or
            service emulator.
        openai_organization:
            OpenAI organization ID. If not passed in will be read from env
            var `OPENAI_ORG_ID`.
        request_timeout:
            Timeout for requests to OpenAI completion API.
        max_retries:
            Maximum number of retries to make when generating.
        batch_size:
            Batch size to use when passing multiple documents to generate.

    See full list of supported init args and their descriptions in the params section.

    Instantiate:
        ```python
        from langchain_openai.llms.base import BaseOpenAI

        model = BaseOpenAI(
            model_name="gpt-3.5-turbo-instruct",
            temperature=0.7,
            max_tokens=256,
            top_p=1,
            frequency_penalty=0,
            presence_penalty=0,
            # openai_api_key="...",
            # openai_api_base="...",
            # openai_organization="...",
            # other params...
        )
        ```

    Invoke:
        ```python
        input_text = "The meaning of life is "
        response = model.invoke(input_text)
        print(response)
        ```

        ```txt
        "a philosophical question that has been debated by thinkers and
        scholars for centuries."
        ```

    Stream:
        ```python
        for chunk in model.stream(input_text):
            print(chunk, end="")
        ```
        ```txt
        a philosophical question that has been debated by thinkers and
        scholars for centuries.
        ```

    Async:
        ```python
        response = await model.ainvoke(input_text)

        # stream:
        # async for chunk in model.astream(input_text):
        #     print(chunk, end="")

        # batch:
        # await model.abatch([input_text])
        ```
        ```
        "a philosophical question that has been debated by thinkers and
        scholars for centuries."
        ```

    NT)defaultexcluder	   clientasync_clientgpt-3.5-turbo-instructmodel)r3   aliasstr
model_namegffffff?floattemperature   int
max_tokens   top_pr   frequency_penaltypresence_penaltynbest_of)default_factorydict[str, Any]model_kwargsapi_keyOPENAI_API_KEY)r3   )r9   rG   z$SecretStr | None | Callable[[], str]openai_api_keybase_urlOPENAI_API_BASE
str | Noneopenai_api_baseorganizationOPENAI_ORG_IDOPENAI_ORGANIZATIONopenai_organizationOPENAI_PROXYopenai_proxy   
batch_sizetimeoutz(float | tuple[float, float] | Any | Nonerequest_timeoutzdict[str, float] | None
logit_bias   max_retriesz
int | Noneseedr*   Fbool	streamingzLiteral['all'] | set[str]allowed_specialallz Literal['all'] | Collection[str]disallowed_specialtiktoken_model_namezMapping[str, str] | Nonedefault_headerszMapping[str, object] | Nonedefault_queryz
Any | Nonehttp_clienthttp_async_clientzMapping[str, Any] | None
extra_body)populate_by_namebefore)modec                0    t        |       }t        ||      S )z>Build extra kwargs from additional params that were passed in.)r   r   )clsvaluesall_required_field_namess      r"   build_extrazBaseOpenAI.build_extra'  s     $<C#@ "6+CDDr$   afterc                2   | j                   dk  rd}t        |      | j                  r| j                   dkD  rd}t        |      | j                  r| j                  dkD  rd}t        |      d}| j                  Vt        | j                  t              r| j                  j                         }n!t        | j                        r| j                  }|| j                  | j                  | j                  | j                  | j                  | j                  d}| j                  s4d| j                   i}t#        j$                  di ||j&                  | _        | j(                  s4d| j*                  i}t#        j,                  di ||j&                  | _        | S )	z?Validate that api key and python package exists in environment.rA   zn must be at least 1.z!Cannot stream results when n > 1.z'Cannot stream results when best_of > 1.N)rJ   rQ   rM   rY   r]   re   rf   rg    )rE   
ValueErrorr`   rF   rL   
isinstancer   get_secret_valuecallablerT   rP   rZ   r]   re   rf   r5   rg   openaiOpenAIcompletionsr6   rh   AsyncOpenAI)selfmsgapi_key_valueclient_paramssync_specificasync_specifics         r"   validate_environmentzBaseOpenAI.validate_environment.  su    66A:)CS/!>>dffqj5CS/!>>dllQ.;CS/! 9=*$--y9 $ 3 3 D D F$--. $ 3 3 % 44,,++++#33!//
 {{*D,<,<=M --I-I=IUUDK  +T-C-CDN & 2 2 !! ! k 
 r$   c                   | j                   | j                  | j                  | j                  | j                  | j
                  | j                  d}| j                  | j                  |d<   | j                  | j                  |d<   | j                  | j                  |d<   | j                  dkD  r| j                  |d<   i || j                  S )z2Get the default parameters for calling OpenAI API.)r=   rB   rC   rD   rE   r^   r*   r[   r@   ri   rA   rF   )r=   rB   rC   rD   rE   r^   r*   r[   r@   ri   rF   rI   )r}   normal_paramss     r"   _default_paramszBaseOpenAI._default_paramsX  s      ++ZZ!%!7!7 $ 5 5II)
 ??&*.//M,'??&*.//M,'??&*.//M,' <<!'+||M)$5-54#4#455r$   c              +    K   i | j                   |ddi}| j                  ||g|        | j                  j                  dd|i|D ]w  }t	        |t
              s|j                         }t        |      }|rD|j                  |j                  || j                  |j                  r|j                  d   nd        | y y wNstreamTpromptr*   )chunkverboser*   rt   )_invocation_paramsget_sub_promptsr5   createrv   dict
model_dumpr0   on_llm_new_tokenr(   r   r-   r}   r   stoprun_managerkwargsparamsstream_respr   s           r"   _streamzBaseOpenAI._streamu  s      GD++FvFxFVfXt4-4;;--FVFvF 	Kk40)4468EE,,JJ LL !00 --j9! - 	 K!	s   CCc                 K   i | j                   |ddi}| j                  ||g|        | j                  j                  dd|i| d {   2 3 d {   }t	        |t
              s|j                         }t        |      }|rL|j                  |j                  || j                  |j                  r|j                  d   nd        d {    | 7 7 7 6 y wr   )r   r   r6   r   rv   r   r   r0   r   r(   r   r-   r   s           r"   _astreamzBaseOpenAI._astream  s     GD++FvFxFVfXt4'?t'8'8'?'? (
(
#(
 "
 	 	+ k40)4468EE!22JJ LL !00 --j9! 3 	 	 	 K%"
 		"
sI   A
C!CC!CCCA5C!CC!CC!C!c                v   | j                   }i ||}| j                  |||      }g }i }h d}	d}
|D ]o  }| j                  rt        |      dkD  rd}t	        |      d} | j
                  |d   ||fi |D ]  }||}||z  } |d}t	        |      |j                  |j                  |j                  r|j                  j                  d      nd|j                  r|j                  j                  d      ndd	        | j                  j                  dd
|i|}t        |t              s|j                         }|j                  d      rt	        |j                  d            |j                  |d          t!        |	||       |
r_|j                  d      }
r | j#                  |||||
      S )a  Call out to OpenAI's endpoint with k unique prompts.

        Args:
            prompts: The prompts to pass into the model.
            stop: Optional list of stop words to use when generating.
            run_manager: Optional callback manager to use for the call.

        Returns:
            The full LLM output.

        Example:
            ```python
            response = openai.generate(["Tell me a joke."])
            ```
        >   total_tokensprompt_tokenscompletion_tokensNrA   ,Cannot stream results with multiple prompts.r   $Generation is empty after streaming.r)   r*   r(   r)   r*   r   errorr&   system_fingerprintr   rt   )r   r   r`   lenru   r   appendr(   r-   r.   r5   r   rv   r   r   extendr#   create_llm_resultr}   promptsr   r   r   r   sub_promptsr&   r   _keysr   _promptsr~   
generationr   r   s                   r"   	_generatezBaseOpenAI._generate  s   . ((%F%f%**67DA&( G)-# /	LH~~x=1$HC$S/)59
)T\\(1+t[SFS ,E!)%*
"e+
	,
 %@C$S/) *  *99 '66::?K!%  *99 '66:::F!%  .4;;--HXHH!(D1  (224H <<($X\\'%:;;x	23#E8[A))16J)K&_/	L` %%WfkFX & 
 	
r$   c                   K   | j                   }i ||}| j                  |||      }g }i }h d}	d}
|D ]  }| j                  rIt        |      dkD  rd}t	        |      d} | j
                  |d   ||fi |2 3 d{   }||}||z  } | j                  j                  dd
|i| d{   }t        |t              s|j                         }|j                  |d          t!        |	||        | j#                  |||||
      S 7 6 |d}t	        |      |j                  |j                  |j                  r|j                  j                  d      nd|j                  r|j                  j                  d      ndd	       X7 ޭw)z:Call out to OpenAI's endpoint async with k unique prompts.>   r   r   r   NrA   r   r   r   r)   r*   r   r   r&   r   rt   )r   r   r`   r   ru   r   r   r(   r-   r.   r6   r   rv   r   r   r   r#   r   r   s                   r"   
_ageneratezBaseOpenAI._agenerate  s     ((%F%f%**67DA&( G)-# %	BH~~x=1$HC$S/)59
#04==QK{$6<$ , ,% ")%*
"e+
( ":!2!2!9!9!T!TV!TT!(D1'224Hx	23#E8[AK%	BL %%WfkFX & 
 	
?, $ %@C$S/) *  *99 '66::?K!%  *99 '66:::F!%  Us8   A6F8D<D=D -F-F.AFDB Fc                
   |||d<   |d   dk(  r2t        |      dk7  rd}t        |      | j                  |d         |d<   t        dt        |      | j                        D cg c]  }|||| j                  z     c}S c c}w )z!Get the sub prompts for llm call.r   r@   rA   z7max_tokens set to -1 not supported for multiple inputs.r   )r   ru   max_tokens_for_promptrangerX   )r}   r   r   r   r~   is         r"   r   zBaseOpenAI.get_sub_prompts<  s     !F6N,2%7|q O o%#'#=#=gaj#IF<  1c'lDOO<
 ADOO+,
 	
 
s   $B r   c               l   g }|j                  d| j                        }t        |      D ]a  \  }}	|||z  |dz   |z   }
|j                  |
D cg c]3  }t	        |d   |j                  d      |j                  d      d      5 c}       c || j
                  d}|r||d	<   t        ||
      S c c}w )z2Create the LLMResult from the choices and prompts.rE   rA   r(   r)   r*   r+   r,   )r   r;   r   )generations
llm_output)r.   rE   	enumerater   r   r;   r   )r}   r&   r   r   r   r   r   rE   r   _sub_choiceschoicer   s                r"   r   zBaseOpenAI.create_llm_resultO  s     JJsDFF#g& 	DAq!!a%1q5A+6K #.	  #F^-3ZZ-H(.

:(>)		 &1P
/AJ+,[ZHH	s   8B1
c                    | j                   S )z,Get the parameters used to invoke the model.)r   r}   s    r"   r   zBaseOpenAI._invocation_paramsn  s     ###r$   c                6    d| j                   i| j                  S )zGet the identifying parameters.r;   )r;   r   r   s    r"   _identifying_paramszBaseOpenAI._identifying_paramss  s     dooF1E1EFFr$   c                     y)zReturn type of llm.ry   rt   r   s    r"   	_llm_typezBaseOpenAI._llm_typex  s     r$   c                   | j                   | j                  |      S t        j                  d   dk  rt        |   |      S | j
                  xs | j                  }	 t        j                  |      }|j                  || j                  | j                        S # t        $ r t        j                  d      }Y Hw xY w)z-Get the token IDs using the tiktoken package.rA      cl100k_base)ra   rc   )custom_get_token_idssysversion_infosuperget_num_tokensrd   r;   tiktokenencoding_for_modelKeyErrorget_encodingencodera   rc   )r}   r(   r;   enc	__class__s       r"   get_token_idszBaseOpenAI.get_token_ids}  s    $$0,,T22A"7)$//--@
	7--j9C zz 00#66  
 	
  	7''6C	7s   B B=<B=c                @   i ddddddddddddd	d
dd
dd
dddddddddddddddddddddddddddd}d| v r| j                  d      d   } |j                  |       }|/t        d |  d!d"j                  |j	                               z         |S )#am  Calculate the maximum number of tokens possible to generate for a model.

        Args:
            modelname: The modelname we want to know the context size for.

        Returns:
            The maximum context size

        Example:
            ```python
            max_tokens = openai.modelname_to_contextsize("gpt-3.5-turbo-instruct")
            ```
        zgpt-4o-minii  zgpt-4ozgpt-4o-2024-05-13zgpt-4i    z
gpt-4-0314z
gpt-4-0613z	gpt-4-32ki   zgpt-4-32k-0314zgpt-4-32k-0613zgpt-3.5-turboi   zgpt-3.5-turbo-0301zgpt-3.5-turbo-0613zgpt-3.5-turbo-16ki@  zgpt-3.5-turbo-16k-0613r7   ztext-ada-001i  adai  i  iA  i   )ztext-babbage-001babbageztext-curie-001curiedavinciztext-davinci-003ztext-davinci-002zcode-davinci-002zcode-davinci-001zcode-cushman-002zcode-cushman-001zft-:r   zUnknown model: z=. Please provide a valid OpenAI model name.Known models are: z, )splitr.   ru   joinr   )	modelnamemodel_token_mappingcontext_sizes      r"   modelname_to_contextsizez#BaseOpenAI.modelname_to_contextsize  sp   
7
g
  
 T	

 $
 $
 
 e
 e
 T
 !$
 !$
  
 %e
 %d
  D!
" 4#
$ !%" $ $ $ $ $ $9
@ I!,Q/I*..y9!) -% %'+yy1D1I1I1K'LM 
 r$   c                8    | j                  | j                        S )z$Get max context size for this model.)r   r;   r   s    r"   max_context_sizezBaseOpenAI.max_context_size  s     ,,T__==r$   c                B    | j                  |      }| j                  |z
  S )an  Calculate the maximum number of tokens possible to generate for a prompt.

        Args:
            prompt: The prompt to pass into the model.

        Returns:
            The maximum number of tokens to generate for a prompt.

        Example:
            ```python
            max_tokens = openai.max_tokens_for_prompt("Tell me a joke.")
            ```
        )r   r   )r}   r   
num_tokenss      r"   r   z BaseOpenAI.max_tokens_for_prompt  s%     ((0
$$z11r$   )ro   rH   returnr	   )r   r   r   rH   )NN)
r   r:   r   list[str] | Noner   CallbackManagerForLLMRun | Noner   r	   r   zIterator[GenerationChunk])
r   r:   r   r   r   $AsyncCallbackManagerForLLMRun | Noner   r	   r   zAsyncIterator[GenerationChunk])
r   	list[str]r   r   r   r   r   r	   r   r   )
r   r   r   r   r   r   r   r	   r   r   )N)r   rH   r   r   r   r   r   zlist[list[str]])r&   r	   r   r   r   rH   r   zdict[str, int]r   rO   r   r   )r   zMapping[str, Any])r   r:   )r(   r:   r   z	list[int])r   r:   r   r?   )r   r?   )r   r:   r   r?   )?__name__
__module____qualname____doc__r   r5   __annotations__r6   r;   r=   r@   rB   rC   rD   rE   rF   r   rI   r   rL   r   rP   rT   rV   rX   rZ   r[   r]   r^   r*   r`   setra   rc   rd   re   rf   rg   rh   ri   r   model_configr   classmethodrq   r   propertyr   r   r   r   r   r   r   r   r   r   r   staticmethodr   r   r   __classcell__r   s   @r"   r2   r2   5   s   ob d3FC3dD9L#9$<GLJLK+J( E5D u ;e$AsJ;GSK#(#>L.>V;@9ISW)X<N8  P"'(3Dd*S#OZ  ', 34d
'  O  % > L*  JH@EIAO=  +/J'.DK<D*Hj" It/14O.63;@8@7&** 15O-415M.5 #K" %)z( ,0J(/@ t4L(#E  $E
 '"' #'R 6 6> "&7;	  5	
  
#< "&<@	  :	
  
(@ "&7;	R
R
 R
 5	R

 R
 
R
n "&<@	9
9
 9
 :	9

 9
 
9
~ "&	

 
 	

 

4 *.II I 	I
 $I 'I 
I> $ $ G G  
( 9 9v > >2r$   r2   c                  v     e Zd ZdZedd       Zedd       Zed	 fd       Zed
d       Z	ed	d       Z
 xZS )rz   u
  OpenAI completion model integration.

    Setup:
        Install `langchain-openai` and set environment variable `OPENAI_API_KEY`.

        ```bash
        pip install -U langchain-openai
        export OPENAI_API_KEY="your-api-key"
        ```

    Key init args — completion params:
        model:
            Name of OpenAI model to use.
        temperature:
            Sampling temperature.
        max_tokens:
            Max number of tokens to generate.
        logprobs:
            Whether to return logprobs.
        stream_options:
            Configure streaming outputs, like whether to return token usage when
            streaming (`{"include_usage": True}`).

    Key init args — client params:
        timeout:
            Timeout for requests.
        max_retries:
            Max number of retries.
        api_key:
            OpenAI API key. If not passed in will be read from env var `OPENAI_API_KEY`.
        base_url:
            Base URL for API requests. Only specify if using a proxy or service
            emulator.
        organization:
            OpenAI organization ID. If not passed in will be read from env
            var `OPENAI_ORG_ID`.

    See full list of supported init args and their descriptions in the params section.

    Instantiate:
        ```python
        from langchain_openai import OpenAI

        model = OpenAI(
            model="gpt-3.5-turbo-instruct",
            temperature=0,
            max_retries=2,
            # api_key="...",
            # base_url="...",
            # organization="...",
            # other params...
        )
        ```

    Invoke:
        ```python
        input_text = "The meaning of life is "
        model.invoke(input_text)
        ```
        ```txt
        "a philosophical question that has been debated by thinkers and scholars for centuries."
        ```

    Stream:
        ```python
        for chunk in model.stream(input_text):
            print(chunk, end="|")
        ```
        ```txt
        a| philosophical| question| that| has| been| debated| by| thinkers| and| scholars| for| centuries|.
        ```

        ```python
        "".join(model.stream(input_text))
        ```
        ```txt
        "a philosophical question that has been debated by thinkers and scholars for centuries."
        ```

    Async:
        ```python
        await model.ainvoke(input_text)

        # stream:
        # async for chunk in (await model.astream(input_text)):
        #    print(chunk)

        # batch:
        # await model.abatch([input_text])
        ```
        ```txt
        "a philosophical question that has been debated by thinkers and scholars for centuries."
        ```
    c                
    g dS )zsGet the namespace of the LangChain object.

        Returns:
            `["langchain", "llms", "openai"]`
        )	langchainllmsry   rt   rn   s    r"   get_lc_namespacezOpenAI.get_lc_namespaceD  s
     /.r$   c                     y)z9Return whether this model can be serialized by LangChain.Trt   r   s    r"   is_lc_serializablezOpenAI.is_lc_serializableM  s     r$   c                4    d| j                   it        |   S )Nr8   )r;   r   r   )r}   r   s    r"   r   zOpenAI._invocation_paramsR  s    GEG,FGGr$   c                
    ddiS )z0Mapping of secret keys to environment variables.rL   rK   rt   r   s    r"   
lc_secretszOpenAI.lc_secretsV  s     !"233r$   c                    i }| j                   r| j                   |d<   | j                  r| j                  |d<   | j                  r| j                  |d<   |S )z$LangChain attributes for this class.rP   rT   rV   )rP   rT   rV   )r}   
attributess     r"   lc_attributeszOpenAI.lc_attributes[  s\     &(
,0,@,@J()##040H0HJ,-)-):):J~&r$   )r   r   )r   r_   r   )r   zdict[str, str])r   r   r   r   r   r   r   r   r   r  r  r   r   s   @r"   rz   rz     sp    ]~ / /   H H 4 4  r$   rz   )r   zset[str]r   rH   r   rH   r   None)r/   rH   r   r   )-r   
__future__r   loggingr   collections.abcr   r   r   r   r   typingr	   r
   ry   r   langchain_core.callbacksr   r   #langchain_core.language_models.llmsr   langchain_core.outputsr   r   r   langchain_core.utilsr   langchain_core.utils.utilsr   r   r   pydanticr   r   r   r   typing_extensionsr   	getLoggerr   loggerr#   r0   r2   rz   rt   r$   r"   <module>r     s    W "  
 R R    8 I I 9 U U B B "			8	$	9
	9,	9;I	9		9#l
2 l
2^DZ Dr$   