Ng[dZddlZddlmZmZmZmZmZmZm Z m Z m Z m Z ddl mZddlmZddlmZmZmZddlmZddlmZdd lmZdd lmZdd lmZmZm Z dd l!m"Z"d ddddZ#dede$fdZ%dede e$e&ffdZ'dede&de&fdZ(dedee$fdZ)dedee$effdZ*de ee$efe eefdee$effdZ+dee ee$efe eefde eeffdZ,dddee ee$efe eefdededee eefd edef d!Z-ddd"e ee$efe efdededee eefd edef d#Z. ddd$dee ee$efe eefdeded%e$deed edefd&Z/ddd$d"e ee$efe efdeded%e$deed edefd'Z0dS)(zAMethods for creating chains that use Ernie function-calling APIs.N) AnyCallableDictListOptionalSequenceTupleTypeUnioncast)LLMChain)BaseLanguageModel)BaseGenerationOutputParserBaseLLMOutputParserBaseOutputParser)BasePromptTemplate)Runnable)is_basemodel_subclass) BaseModel)JsonOutputFunctionsParser!PydanticAttrOutputFunctionsParserPydanticOutputFunctionsParser)"convert_pydantic_to_ernie_functionstringnumberboolean)strintfloatboolfunctionreturnc|jS)z"Get the name of a Python function.)__name__r!s k/var/www/html/ai-engine/env/lib/python3.11/site-packages/langchain_community/chains/ernie_functions/base.py_get_python_function_namer',s  ctj|}|r|d}g}d}d}|D]`}|dr|}nF|ds|drd}H|s||`ad|}nd }d}i}|rd} |d d dD]} d | vrB| d \} } | || <H| r7|| xxd| zz cc<||fS) zParse the function and argument descriptions from the docstring of a function. Assumes the function docstring follows Google Python style guide. z NFzArgs:zReturns:zExample:T  :)inspectgetdocsplit startswithappendjoinstrip) r! docstringdocstring_blocks descriptors args_blockpast_descriptorsblock descriptionarg_descriptionsarglinedescs r& _parse_python_function_docstringrA1s x((I$??622   %  E(( " !!*-- 1A1A*1M1M #'  % ""5))))hh{++   D$$T**122. D DDd{{ JJsOO T04  -- D ---tzz||1CC--- ( ((r(r=c|i}tj|j}|D]\}}|dkr t |t r't |r|||<n%|jtvrdt|ji||<||vr||vri||<||||d<|S)zGet JsonSchema describing a Python functions arguments. Assumes all function arguments are of primitive types (int, float, str, bool) or are subclasses of pydantic.BaseModel. r"typer<) r/getfullargspec annotationsitems isinstancerCrschemar$PYTHON_TO_JSON_TYPES)r!r= propertiesrEr>arg_types r&_get_python_function_argumentsrLWs J(22>K$**,, C C X (??  h % % P*?*I*I P'oo//JsOO  "6 6 6%';Hz6_get_python_function_required_args..ss,TTTqq9L9RPR/S/S/S/S/Sr(rselfr-)r/rDdefaultsargslen kwonlyargsrC)r!requiredis_classrSs @r&"_get_python_function_required_argsr\os  !( + +D37=Oty.C ....//diH TTTTDOTTTTHH~~%H HQK6))ABB< Or(ct|\}}t||dt||t|ddS)aConvert a Python function to an Ernie function-calling API compatible dict. Assumes the Python function has type hints and a docstring with a description. If the docstring has Google Python style argument descriptions, these will be included as well. object)rCrJrZnamer< parameters)rAr'rLr\)r!r<r=s r&)convert_python_function_to_ernie_functionrb{s[%EX$N$N!K!)(33"8CSTT:8DD    r(c8t|tr|St|tr1t|r"t t t |St|rt|Stdt|d)aConvert a raw function/class to an Ernie function. Args: function: Either a dictionary, a pydantic.BaseModel class, or a Python function. If a dictionary is passed in, it is assumed to already be a valid Ernie function. Returns: A dict version of the passed in function which is compatible with the Ernie function-calling API. zUnsupported function type zG. Functions must be passed in as Dict, pydantic.BaseModel, or Callable.) rGdictrCrr rrcallablerb ValueErrorr%s r&convert_to_ernie_functionrgs(D!!   Hd # #  (=h(G(G  D.s&NNNq/226:NNNr(rr-ci|]\}}|| SrOrO)rQr`fns r& z+get_ernie_output_parser..s+===%T2b===r()pydantic_schema) args_only)rGrCrrXziprr)rhfunction_namesrq output_parsers r&get_ernie_output_parserrvs ONINNNN)A,%% Q*? ! *M*M Q y>>A  ==),^Y)G)G===OO(lO )/ J J J  2C NNa RecordDog(name="Harry", color="brown", fav_food="chicken") 5Need to pass in at least one function. Received zero.c,g|]}t|SrOrkrls r&rTz,create_ernie_fn_runnable..!GGG033GGGr(rhr-r`r function_callrO)rfrXrvbind)rhrwrxruryernie_functions llm_kwargss r&create_ernie_fn_runnablersR RPQQQGGYGGGO"-!I&!IJ ?q  '-q/A&/I&J ?#!G% Dog(name="Harry", color="brown", fav_food="chicken") output_formatterLOutput formatter. Should always be used to format your response to the user.r_c eZdZUdZed<dS);create_structured_output_runnable.._OutputFormatterroutputNr$ __module__ __qualname____doc____annotations__rsr&_OutputFormatterr`% ^ ^! ! ! ! ! !r(rrrq attr_nameru)rGrdrrr)rrwrxruryr!rs` r&!create_structured_output_runnablersl-&& &(    " " " " " " "y " " " $% )J,* * *  $     $      r( output_keyrurc |stdd|D}|pt|}d|i}t|dkrd|ddi|d<td |||||d|}|S) a [Legacy] Create an LLM chain that uses Ernie functions. Args: functions: A sequence of either dictionaries, pydantic.BaseModels classes, or Python functions. If dictionaries are passed in, they are assumed to already be a valid Ernie functions. If only a single function is passed in, then it will be enforced that the model use that function. pydantic.BaseModels and Python functions should have docstrings describing what the function does. For best results, pydantic.BaseModels should have descriptions of the parameters and Python functions should have Google Python style args descriptions in the docstring. Additionally, Python functions should only use primitive types (str, int, float, bool) or pydantic.BaseModels for arguments. llm: Language model to use, assumed to support the Ernie function-calling API. prompt: BasePromptTemplate to pass to the model. output_key: The key to use when returning the output in LLMChain.__call__. output_parser: BaseLLMOutputParser to use for parsing model outputs. By default will be inferred from the function types. If pydantic.BaseModels are passed in, then the OutputParser will try to parse outputs using those. Otherwise model outputs will simply be parsed as JSON. If multiple functions are passed in and they are not pydantic.BaseModels, the chain output will include both the name of the function that was returned and the arguments to pass to the function. Returns: An LLMChain that will pass in the given functions to the model when run. Example: .. code-block:: python from typing import Optional from langchain.chains.ernie_functions import create_ernie_fn_chain from langchain_community.chat_models import ErnieBotChat from langchain_core.prompts import ChatPromptTemplate from pydantic import BaseModel, Field class RecordPerson(BaseModel): """Record some identifying information about a person.""" name: str = Field(..., description="The person's name") age: int = Field(..., description="The person's age") fav_food: Optional[str] = Field(None, description="The person's favorite food") class RecordDog(BaseModel): """Record some identifying information about a dog.""" name: str = Field(..., description="The dog's name") color: str = Field(..., description="The dog's color") fav_food: Optional[str] = Field(None, description="The dog's favorite food") llm = ErnieBotChat(model_name="ERNIE-Bot-4") prompt = ChatPromptTemplate.from_messages( [ ("user", "Make calls to the relevant function to record the entities in the following input: {input}"), ("assistant", "OK!"), ("user", "Tip: Make sure to answer in the correct format"), ] ) chain = create_ernie_fn_chain([RecordPerson, RecordDog], llm, prompt) chain.run("Harry was a chubby brown beagle who loved chicken") # -> RecordDog(name="Harry", color="brown", fav_food="chicken") r{c,g|]}t|SrOrkrls r&rTz)create_ernie_fn_chain..r}r(rhr-r`rr~)rwrxrurrrO)rfrvrXr ) rhrwrxrruryrr llm_chains r&create_ernie_fn_chainrusX RPQQQGGYGGGO!G% Dog(name="Harry", color="brown", fav_food="chicken") rrr_c eZdZUdZed<dS)8create_structured_output_chain.._OutputFormatterrrNrrsr&rrrr(rrrr)rGrdrrr)rrwrxrruryr!rs` r&create_structured_output_chainrsr-&& &(    " " " " " " "y " " " $% )J,* * *  !    #       r()1rr/typingrrrrrrr r r r langchain.chainsr langchain_core.language_modelsrlangchain_core.output_parsersrrrlangchain_core.promptsrlangchain_core.runnablesrlangchain_core.utils.pydanticrpydanticr2langchain_community.output_parsers.ernie_functionsrrr)langchain_community.utils.ernie_functionsrrIrr'rdrArLr\rbrgrvrrrrrOr(r&rsPGG                        &%%%%%<<<<<< 655555------?????? YXXXXX     S #)x#)E#t)  #s(^    8d38nd9oxGHI 7 78JTX P;P;P;d38nd9oxGHIP; P; P; E"24N"NOP P;  P;P;P;P;P;pTX PPPc3hi89P P P E"24N"NOP P  PPPPPf!37 ]]]d38nd9oxGHI] ] ]  ] /0 ]]]]]]J!37 TTTc3hi89T T T  T /0 TTTTTTTTr(