
    j
iy                    >   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j&        e'          Z(ddZ)ddZ* G d de          Z+ G d de+          Z,dS )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)Selfkeysset[str]responsedict[str, Any]token_usagereturnNonec                    |                      |d                   }|D ]4}||vr|d         |         ||<   ||xx         |d         |         z  cc<   5dS )zUpdate token usage.usageN)intersection)r   r   r   _keys_to_use_keys        C:\Users\Dell Inspiron 16\Desktop\tws\AgrotaPowerBi\back-agrota-powerbi\mcp-client-agrota\venv\Lib\site-packages\langchain_openai/llms/base.py_update_token_usager'      s     $$Xg%677L 9 9{"" ( 1$ 7K'!24!88	9 9    stream_responser   c                   | d         st          d          S t          | d         d         d         pd| d         d                             dd          | d         d                             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)r)   s    r&   $_stream_response_to_generation_chunkr4   &   s     9% (B''''Y'*628b,Y7:>>PTUU'	21599*dKK
 
   r(   c                      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+dydP                        Z, e*dQM          dzdS            Z-e.d{dT            Z/	 	 d|d}d\Z0	 	 d|d~d_Z1	 	 d|ddcZ2	 	 d|dddZ3	 dddgZ4ddhddmZ5e.d{dn            Z6e.ddp            Z7e.ddq            Z8d fdtZ9e:ddv            Z;e.ddw            Z<ddxZ= xZ>S )
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)r7   aliasstr
model_namegffffff?floattemperature   int
max_tokens   top_pr   frequency_penaltypresence_penaltynbest_of)default_factoryr   model_kwargsapi_keyOPENAI_API_KEY)r7   )r=   rK   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)modevaluesr   c                @    t          |           }t          ||          S )z>Build extra kwargs from additional params that were passed in.)r   r   )clsrp   all_required_field_namess      r&   build_extrazBaseOpenAI.build_extra'  s#     $<C#@#@ "6+CDDDr(   afterr   c                ~   | j         dk     rd}t          |          | j        r| j         dk    rd}t          |          | j        r| j        dk    rd}t          |          d}| j        Ot          | j        t                    r| j                                        }nt          | j                  r| j        }|| j	        | j
        | j        | j        | j        | j        d}| j        s&d| j        i}t#          j        di ||j        | _        | j        s&d| j        i}t#          j        di ||j        | _        | S )	z?Validate that api key and python package exists in environment.rE   zn must be at least 1.z!Cannot stream results when n > 1.z'Cannot stream results when best_of > 1.N)rM   rT   rP   r\   r`   rh   ri   rj    )rI   
ValueErrorrc   rJ   rO   
isinstancer   get_secret_valuecallablerW   rS   r]   r`   rh   ri   r9   rj   openaiOpenAIcompletionsr:   rk   AsyncOpenAI)selfmsgapi_key_valueclient_paramssync_specificasync_specifics         r&   validate_environmentzBaseOpenAI.validate_environment.  s    6A::)CS//!> 	"dfqjj5CS//!> 	"dlQ..;CS//! 9=*$-y99 4 $ 3 D D F F$-.. 4 $ 3 % 4,++#3!/
 
 { 	V*D,<=M -II-I=IIUDK  	+T-CDN & 2 ! !! ! !  
 r(   c                   | j         | j        | j        | j        | j        | j        | j        d}| j        
| j        |d<   | j        
| j        |d<   | j	        
| j	        |d<   | j
        dk    r
| j
        |d<   i || j        S )z2Get the default parameters for calling OpenAI API.)rA   rF   rG   rH   rI   ra   r/   Nr^   rD   rl   rE   rJ   )rA   rF   rG   rH   rI   ra   r/   r^   rD   rl   rJ   rL   )r   normal_paramss     r&   _default_paramszBaseOpenAI._default_paramsX  s      +Z!%!7 $ 5I)
 )
 ?&*./M,'?&*./M,'?&*./M,' <!'+|M)$5-54#455r(   promptstoplist[str] | Nonerun_managerCallbackManagerForLLMRun | NonekwargsIterator[GenerationChunk]c              +  p  K   i | j         |ddi}|                     ||g|            | j        j        dd|i|D ]w}t	          |t
                    s|                                }t          |          }|r7|                    |j	        || j
        |j        r|j        d         nd            |V  xd S NstreamTr   r/   )chunkverboser/   rw   )_invocation_paramsget_sub_promptsr9   createry   dict
model_dumpr4   on_llm_new_tokenr-   r   r2   r   r   r   r   r   paramsstream_respr   s           r&   _streamzBaseOpenAI._streamu  s       GD+FvFxFFVfXt444-4;-FFVFvFF 	 	Kk400 7)44668EEE 
,,J L !0"-j99! - 	 	 	 KKKK!	 	r(   $AsyncCallbackManagerForLLMRun | NoneAsyncIterator[GenerationChunk]c                 K   i | j         |ddi}|                     ||g|            | j        j        dd|i| d {V 2 3 d {V }t	          |t
                    s|                                }t          |          }|r=|                    |j	        || j
        |j        r|j        d         nd            d {V  |W V  6 d S r   )r   r   r:   r   ry   r   r   r4   r   r-   r   r2   r   s           r&   _astreamzBaseOpenAI._astream  si      GD+FvFxFFVfXt444'?t'8'? (
 (
(
#(
 (
 "
 "
 "
 "
 "
 "
 	 	 	 	 	 	 	+ k400 7)44668EEE 
!22J L !0"-j99! 3 	 	 	 	 	 	 	 	 	 KKKKK%"
 "
 "
s   Cprompts	list[str]r   c                   | j         }i ||}|                     |||          }g }i }h d}	d}
|D ]~}| j        rt          |          dk    rd}t	          |          d} | j        |d         ||fi |D ]}||}||z  }|d}t	          |          |                    |j        |j        r|j        	                    d          nd|j        r|j        	                    d          ndd	            | j
        j        dd
|i|}t          |t                    s|                                }|	                    d          r"t	          |	                    d                    |                    |d                    t!          |	||           |
s|	                    d          }
|                     |||||
          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_tokensNrE   ,Cannot stream results with multiple prompts.r   $Generation is empty after streaming.r.   r/   r-   r.   r/   r   errorr+   system_fingerprintr   rw   )r   r   rc   lenrx   r   appendr-   r2   r3   r9   r   ry   r   r   extendr'   create_llm_resultr   r   r   r   r   r   sub_promptsr+   r   _keysr   _promptsr   
generationr   r   s                   r&   	_generatezBaseOpenAI._generate  sI   . (%F%f%**67DAA&( GFF)-# /	L /	LH~ .Lx==1$$HC$S//)59
)T\(1+t[SSFSS , ,E!)%*

"e+

%@C$S//) *  *9&J6::?KKK!%  *9&J6:::FFF!%      .4;-HHXHHH!(D11 5  (2244H <<(( <$X\\'%:%:;;;x	2333#E8[AAA) L)16J)K)K&%%WfkFX & 
 
 	
r(   c                  K   | j         }i ||}|                     |||          }g }i }h d}	d}
|D ]<}| j        rt          |          dk    rd}t	          |          d} | j        |d         ||fi |2 3 d{V }||}||z  }6 |d}t	          |          |                    |j        |j        r|j        	                    d          nd|j        r|j        	                    d          ndd	            | j
        j        dd
|i| d{V }t          |t                    s|                                }|                    |d                    t!          |	||           >|                     |||||
          S )z:Call out to OpenAI's endpoint async with k unique prompts.r   NrE   r   r   r   r.   r/   r   r   r+   r   rw   )r   r   rc   r   rx   r   r   r-   r2   r3   r:   r   ry   r   r   r   r'   r   r   s                   r&   
_ageneratezBaseOpenAI._agenerate  s@      (%F%f%**67DAA&( GFF)-# %	B %	BH~ $Bx==1$$HC$S//)59
#04=QK{$ $6<$ $ , , , , , , ,% ")%*

"e+

$ %@C$S//) *  *9&J6::?KKK!%  *9&J6:::FFF!%      ":!2!9!T!T!TV!T!TTTTTTT!(D11 5'2244Hx	2333#E8[AAAA%%WfkFX & 
 
 	
s   9Br   list[list[str]]c                    |||d<   |d         dk    rBt                    dk    rd}t          |                               d                   |d<    fdt          dt                     j                  D             S )	z!Get the sub prompts for llm call.Nr   rD   rE   z7max_tokens set to -1 not supported for multiple inputs.r   c                4    g | ]}||j         z            S rw   )r[   ).0ir   r   s     r&   
<listcomp>z.BaseOpenAI.get_sub_prompts.<locals>.<listcomp>J  s:     
 
 
 ADO++,
 
 
r(   )r   rx   max_tokens_for_promptranger[   )r   r   r   r   r   s   ` `  r&   r   zBaseOpenAI.get_sub_prompts<  s     !F6N,2%%7||q  O oo%#'#=#=gaj#I#IF< 
 
 
 
 
1c'llDO<<
 
 
 	
r(   r   r+   r   dict[str, int]r   c                  g }|                     d| j                  }t          |          D ]7\  }}	|||z  |dz   |z           }
|                    d |
D                        8|| j        d}|r||d<   t          ||          S )z2Create the LLMResult from the choices and prompts.rI   rE   c           	         g | ]B}t          |d          |                    d          |                    d          d          CS )r-   r.   r/   r0   r1   )r   r3   )r   choices     r&   r   z0BaseOpenAI.create_llm_result.<locals>.<listcomp>^  sh     	 	 	  #F^-3ZZ-H-H(.

:(>(>) )  	 	 	r(   )r   r?   r   )generations
llm_output)r3   rI   	enumerater   r?   r   )r   r+   r   r   r   r   r   rI   r   _sub_choicesr   s               r&   r   zBaseOpenAI.create_llm_resultO  s     JJsDF##g&& 	 	DAq!!a%1q5A+"56K	 	 #.	 	 	    &1PP
 	B/AJ+,[ZHHHHr(   c                    | j         S )z,Get the parameters used to invoke the model.)r   r   s    r&   r   zBaseOpenAI._invocation_paramsn  s     ##r(   Mapping[str, Any]c                "    d| j         i| j        S )zGet the identifying parameters.r?   )r?   r   r   s    r&   _identifying_paramszBaseOpenAI._identifying_paramss  s     doF1EFFr(   c                    dS )zReturn type of llm.r|   rw   r   s    r&   	_llm_typezBaseOpenAI._llm_typex  s	     xr(   r-   	list[int]c                ~   | j         |                      |          S t          j        d         dk     r!t                                          |          S | j        p| j        }	 t          j        |          }n$# t          $ r t          j
        d          }Y nw xY w|                    || j        | j                  S )z-Get the token IDs using the tiktoken package.NrE      cl100k_base)rd   rf   )custom_get_token_idssysversion_infosuperget_num_tokensrg   r?   tiktokenencoding_for_modelKeyErrorget_encodingencoderd   rf   )r   r-   r?   enc	__class__s       r&   get_token_idszBaseOpenAI.get_token_ids}  s    $0,,T222A""77))$///-@
	7-j99CC 	7 	7 	7'66CCC	7 zz 0#6  
 
 	
s   $A9 9BB	modelnamec                   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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/| v r|                      d0          d1         } |                    |           }|;t          d3|  d4d5                    |                                          z             |S )6am  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-5.2i zgpt-5.2-2025-12-11zgpt-5.1zgpt-5.1-2025-11-13zgpt-5zgpt-5-2025-08-07z
gpt-5-minizgpt-5-mini-2025-08-07z
gpt-5-nanozgpt-5-nano-2025-08-07z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-0613r;   ztext-ada-001i  adaztext-babbage-001i  babbageztext-curie-001curiedavinciztext-davinci-003i  ztext-davinci-002iA  i   )zcode-davinci-002zcode-davinci-001zcode-cushman-002zcode-cushman-001zft-:r   NzUnknown model: z=. Please provide a valid OpenAI model name.Known models are: z, )splitr3   rx   joinr   )r   model_token_mappingcontext_sizes      r&   modelname_to_contextsizez#BaseOpenAI.modelname_to_contextsize  s\   '
w'
 ''
 w'
 !'	'

 W'
 '
 ''
 $W'
 ''
 $W'
 7'
 g'
  '
 T'
 $'
  $!'
" #'
 '
$ e%'
& e''
( T)'
* !$+'
, !$-'
.  /'
0 %e1'
2 %d3'
4 D5'
6 47'
8 9'
: t;'
< d='
> T?'
@ tA'
B C'
D E'
 '
F !% $ $ $M'
 '
 '
T I!,,Q/I*..y99%) % % %'+yy1D1I1I1K1K'L'LM  
 r(   c                6    |                      | 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                @    |                      |          }| 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0
$z11r(   )rp   r   r   r	   )r   r   r   r   )NN)
r   r>   r   r   r   r   r   r	   r   r   )
r   r>   r   r   r   r   r   r	   r   r   )
r   r   r   r   r   r   r   r	   r   r   )
r   r   r   r   r   r   r   r	   r   r   )N)r   r   r   r   r   r   r   r   )r+   r	   r   r   r   r   r   r   r   rR   r   r   )r   r   )r   r>   )r-   r>   r   r   )r   r>   r   rC   )r   rC   )r   r>   r   rC   )?__name__
__module____qualname____doc__r   r9   __annotations__r:   r?   rA   rD   rF   rG   rH   rI   rJ   r   rL   r   rO   r   rS   rW   rY   r[   r]   r^   r`   ra   r/   rc   setrd   rf   rg   rh   ri   rj   rk   rl   r   model_configr   classmethodrt   r   propertyr   r   r   r   r   r   r   r   r   r   r   staticmethodr   r   r   __classcell__r   s   @r&   r6   r6   5   s        o ob %d333F3333dD999L9999e$<GLLLJLLLLK+J( ED     ;$AJJJJ;GK#(5#>#>#>L>>>>V;@59ISW)X)X)X< < <N     P"'%((3Dd*S*S*S# # #O     ',e 34d
 
 
' ' '     O  %u >>>     L     JH@EIA A AO     +/J....DK<DH" I/14O66663;@@@@@7&***** 15O444415M5555 #K"""" %)(((( ,0J////@ :t444L_(###E E E [ $#E
 _'"""' ' ' #"'R 6 6 6 X6> "&7;	    < "&<@	    @ "&7;	R
 R
 R
 R
 R
n "&<@	9
 9
 9
 9
 9
~ "&	
 
 
 
 
4 *.I I I I I I> $ $ $ X$ G G G XG    X
 
 
 
 
 
( C C C \CJ > > > X>2 2 2 2 2 2 2 2r(   r6   c                       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 )r}   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."
        ```
    r   r   c                
    g dS )zsGet the namespace of the LangChain object.

        Returns:
            `["langchain", "llms", "openai"]`
        )	langchainllmsr|   rw   rr   s    r&   get_lc_namespacezOpenAI.get_lc_namespaceN  s     /...r(   rb   c                    dS )z9Return whether this model can be serialized by LangChain.Trw   r  s    r&   is_lc_serializablezOpenAI.is_lc_serializableW  s	     tr(   r   c                <    d| j         it                      j        S )Nr<   )r?   r   r   )r   r   s    r&   r   zOpenAI._invocation_params\  s    GEGG,FGGr(   dict[str, str]c                
    ddiS )z0Mapping of secret keys to environment variables.rO   rN   rw   r   s    r&   
lc_secretszOpenAI.lc_secrets`  s     !"233r(   c                p    i }| j         r
| j         |d<   | j        r
| j        |d<   | j        r
| j        |d<   |S )z$LangChain attributes for this class.rS   rW   rY   )rS   rW   rY   )r   
attributess     r&   lc_attributeszOpenAI.lc_attributese  s[     &(
 	A,0,@J()# 	I040HJ,- 	;)-):J~&r(   )r   r   )r   rb   r   )r   r  )r   r   r   r   r   r	  r  r   r   r  r  r  r  s   @r&   r}   r}     s        ] ]~ / / / [/    [ H H H H H XH 4 4 4 X4    X    r(   r}   )r   r   r   r   r   r   r   r    )r)   r   r   r   )-r   
__future__r   loggingr   collections.abcr   r   r   r   r   typingr	   r
   r|   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'   r4   r6   r}   rw   r(   r&   <module>r      s   W W " " " " " "  



 R R R R R R R R R R R R R R                  8 7 7 7 7 7 I I I I I I I I I I 9 9 9 9 9 9 U U U U U U U U U U B B B B B B B B B B B B " " " " " "		8	$	$	9 	9 	9 	9   v
2 v
2 v
2 v
2 v
2 v
2 v
2 v
2rD D D D DZ D D D D Dr(   