gh_UdZddlmZddlZddlZddlmZddlmZm Z m Z ddl m Z ddl mZmZmZmZmZmZddlmZdd lmZmZdd lmZdd lmZmZdd lmZm Z m!Z!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-erddl.m/Z/Gddee*e+fZ0Gdde0e*e+fZ1Gdde2ej3Z4eZ5de6d<ej7Z8Gdde0e*e+fZ9d%dZ:d&d Z;d'd$ZdZe ds r1rBzDynamicRunnable.OutputTypeUs|&&r3type[BaseModel]c\||\}}||Sr<)prepareget_input_schemar?r)r8s r1rFz DynamicRunnable.get_input_schemaZs. <<//&((000r3c\||\}}||Sr<)rEget_output_schemarGs r1rIz!DynamicRunnable.get_output_schemaas. <<//&))&111r3r#c\||\}}||Sr<)rE get_graphrGs r1rKzDynamicRunnable.get_graphhs,<<//&!!&)))r3kwargsr Runnable[Input, Output]c h|jdii|jdtt||iS)Nr)r.) __class____dict__rr)r?r)rLs r1 with_configzDynamicRunnable.with_configmsJt~  WW- ff8U8U*V*VWW   r3.tuple[Runnable[Input, Output], RunnableConfig]c|}t|tr@|t|j|\}}t|t@|t d|fS)zPrepare the Runnable for invocation. Args: config: The configuration to use. Defaults to None. Returns: tuple[Runnable[Input, Output], RunnableConfig]: The prepared Runnable and configuration. r) isinstancer%_preparerr)rrGs r1rEzDynamicRunnable.preparexsl-1?33 Y'00xPV1W1WXX Hf?33 Y.7777r3cdSr<r.)r?r)s r1rUzDynamicRunnable._prepares :=r3inputrr c P||\}}|j||fi|Sr<)rEinvoker?rWr)rLr8s r1rYzDynamicRunnable.invokes6 <<//&xuf77777r3c`K||\}}|j||fi|d{VSr<)rEainvokerZs r1r\zDynamicRunnable.ainvokesM <<//&%X%eV>>v>>>>>>>>>r3F)return_exceptionsinputs list[Input]5Optional[Union[RunnableConfig, list[RunnableConfig]]]r] Optional[Any] list[Output]c  t|t|}fd|D}tfd|Dr jj|d|DfdiS|sgSdfd }t|d kr't d ||d|dgSt |d5}t d t||||cdddS#1swxYwYdS)Nc:g|]}|Sr.rE.0cr?s r1 z)DynamicRunnable.batch..#555DLLOO555r3c30K|]\}}|juVdSr<r'rgp_r?s r1 z(DynamicRunnable.batch...66TQqDL 666666r3cg|]\}}|Sr.r.rgrorhs r1riz)DynamicRunnable.batch..(((tq!(((r3r]preparedrRrWrr+Union[Output, Exception]c|\}}r) |j||fiS#t$r }|cYd}~Sd}~wwxYw|j||fiSr<)rY ExceptionrurWboundr)erLr]s r1rYz%DynamicRunnable.batch..invokes%ME6  ='5<v@@@@@ HHHHHH$u|E6<.rjr3c30K|]\}}|juVdSr<rlrms r1rpz)DynamicRunnable.abatch..rqr3cg|]\}}|Sr.r.rss r1riz*DynamicRunnable.abatch..rtr3r]rurRrWrr+rvcK|\}}r/ |j||fid{VS#t$r }|cYd}~Sd}~wwxYw|j||fid{VSr<)r\rxrys r1r\z'DynamicRunnable.abatch..ainvokes%ME6  D!.uf!G!G!G!GGGGGGGG HHHHHH+U]5&CCFCCCCCCCCCs! 7277rmax_concurrencyr})rr~rr'abatchrr!get) r?r^r)r]rLrrur\coross ` `` r1rzDynamicRunnable.abatchsH"&#f++665555W555 6666X666 6 6 ,,((x(((#4   I D D D D D D DGXv..,WQZ^^.wrappers & HHHCh"3--'*c11&s>':DAA2,0<<=Ms8S8S+T+T(&!=F!=Hf!=!=6wx66GGGGGG )$ I IHC"3--I*c11&s>':DAA2,0<<=Ms8S8S+T+T(& $T %+c 6wx66HHHHHH;D'+||~~$Hf278T22DCFCCCtT,V,,,r3)rr rLr r+r )rr'callabler)r?rrrs`` @r1 __getattr__zDynamicRunnable.__getattr__sht|T** D>>  4[[ - - - - - - -[ -8N r3)r+r,)r+r4)r+r:)r+r@r<)r)r(r+rC)r)r(r+r#)r)r(rLr r+rMr)r(r+rR)rWrr)r(rLr r+r ) r^r_r)r`r]r,rLrar+rb)rWrr)r(rLrar+r)rWrr)r(rLrar+r)rWrr)r(rLrar+r)rWrr)r(rLrar+r)rrr+r )__name__ __module__ __qualname____doc____annotations__r)r model_config classmethodrr2r9propertyr=rBrFrIrKrQrErrUrYr\rrrrrrrr.r3r1r%r%3s1000'+F++++: $L X[ 333X[3 &&&XX& '''XX'151111X1 152222X2 ****X*,0    X 2688888"15====^=?C8888X8 ?C????X? IM(V #( (V(V(V(V(VX(VTIM$X #( $X$X$X$X$XX$XL,08888X8,0X,0;;;;X;,0X###X###r3r%cZeZdZUdZded<eddZedd Z dddZ d S)RunnableConfigurableFieldsaRunnable that can be dynamically configured. A RunnableConfigurableFields should be initiated using the `configurable_fields` method of a Runnable. Parameters: fields: The configurable fields to use. Here is an example of using a RunnableConfigurableFields with LLMs: .. code-block:: python from langchain_core.prompts import PromptTemplate from langchain_core.runnables import ConfigurableField from langchain_openai import ChatOpenAI model = ChatOpenAI(temperature=0).configurable_fields( temperature=ConfigurableField( id="temperature", name="LLM Temperature", description="The temperature of the LLM", ) ) # This creates a RunnableConfigurableFields for a chat model. # When invoking the created RunnableSequence, you can pass in the # value for your ConfigurableField's id which in this case # will be change in temperature prompt = PromptTemplate.from_template("Pick a random number above {x}") chain = prompt | model chain.invoke({"x": 0}) chain.invoke({"x": 0}, config={"configurable": {"temperature": 0.9}}) Here is an example of using a RunnableConfigurableFields with HubRunnables: .. code-block:: python from langchain_core.prompts import PromptTemplate from langchain_core.runnables import ConfigurableField from langchain_openai import ChatOpenAI from langchain.runnables.hub import HubRunnable prompt = HubRunnable("rlm/rag-prompt").configurable_fields( owner_repo_commit=ConfigurableField( id="hub_commit", name="Hub Commit", description="The Hub commit to pull from", ) ) prompt.invoke({"question": "foo", "context": "bar"}) # Invoking prompt with `with_config` method prompt.invoke( {"question": "foo", "context": "bar"}, config={"configurable": {"hub_commit": "rlm/rag-prompt-llama"}}, ) zdict[str, AnyConfigurableField]fieldsr+list[ConfigurableFieldSpec]c 6g}t|jj}|jD]\}}t |t ro|t|j |j |j p ||j |j p ||j t|j||j|t|||j ||jjt%|S)zGet the configuration specs for the RunnableConfigurableFields. Returns: list[ConfigurableFieldSpec]: The configuration specs. idr description annotationr' is_shared)typer' model_fieldsrrrTrappendrrrrrrrmake_options_specextend config_specsr")r?rdefault_fields field_namespecs r1rz'RunnableConfigurableFields.config_specss' dl++8 $ 1 1 3 3   J$ 122 ##)7!Y$($4%B)*5A#'?$A)*5@ ' j A A"&.       ##%dN:,F,RSS DL5666&|444r3rLrr&c 8|jjdii|j|S)Nr.)r'configurable_fieldsrr?rLs r1rz.RunnableConfigurableFields.configurable_fieldss,0t|/LL2KT[2KF2KLLLr3Nr)r(rRctdjDfddiD}fdjD}fdjD}i|||}|rBfdjjD}jjdii||fSjfS)Nc(i|]\}}|j||fSr.)r)rgrrs r1 z7RunnableConfigurableFields._prepare..s$QQQ Ttwd QQQr3c~i|]9\}}|v t|dt*|d|:S)r|r)rTr)rgkv specs_by_ids r1rz7RunnableConfigurableFields._prepare..sV   1KJ{1~a/@BS$T$T N1 qr3rci|][\}}t|t||jdi|jp|j\S)r)rTroptionsrrr'rgrrr)s r1rz7RunnableConfigurableFields._prepare..sl' ' ' 1!:;;' qy&**^R88<..s/ ! r3r)rTrrrr'rs @r1rz7RunnableConfigurableFields._prepare..s& & & 1!9:: & NB77;;AD!)LL& & & r3cRi|]#\}}|tjjv ||$Sr.)rr'r)rgrrr?s r1rz7RunnableConfigurableFields._prepare..sAAqT\**7771777r3r.)rrrrr'rPrO)r?r)rconfigurable_single_optionsconfigurable_multi_optionsr init_paramsrs`` @r1rUz#RunnableConfigurableFields._preparesv&&QQT[=N=N=P=PQQQ      >266<<>>    ' ' ' '  ))++' ' ' # & & & &  ))++ & & & " ! ) )   L17799K ' &II)HK)H<)HII  f%%r3r+rrLrr+r&r<r) rrrrrrrrrrUr.r3r1rr?s==~,+++ 555X5@MMMXM 26'&'&'&'&'&'&'&r3rceZdZdZdS)StrEnumz String enum.N)rrrrr.r3r1rrsr3rzyWeakValueDictionary[Union[ConfigurableFieldSingleOption, ConfigurableFieldMultiOption, ConfigurableField], type[StrEnum]]_enums_for_specceZdZUdZded< ded< dZded< d ed < eedd ZeddZ dddZ dS) RunnableConfigurableAlternativesa4 Runnable that can be dynamically configured. A RunnableConfigurableAlternatives should be initiated using the `configurable_alternatives` method of a Runnable or can be initiated directly as well. Here is an example of using a RunnableConfigurableAlternatives that uses alternative prompts to illustrate its functionality: .. code-block:: python from langchain_core.runnables import ConfigurableField from langchain_openai import ChatOpenAI # This creates a RunnableConfigurableAlternatives for Prompt Runnable # with two alternatives. prompt = PromptTemplate.from_template( "Tell me a joke about {topic}" ).configurable_alternatives( ConfigurableField(id="prompt"), default_key="joke", poem=PromptTemplate.from_template("Write a short poem about {topic}") ) # When invoking the created RunnableSequence, you can pass in the # value for your ConfigurableField's id which in this case will either be # `joke` or `poem`. chain = prompt | ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0) # The `with_config` method brings in the desired Prompt Runnable in your # Runnable Sequence. chain.with_config(configurable={"prompt": "poem"}).invoke({"topic": "bears"}) Equivalently, you can initialize RunnableConfigurableAlternatives directly and use in LCEL in the same way: .. code-block:: python from langchain_core.runnables import ConfigurableField from langchain_core.runnables.configurable import RunnableConfigurableAlternatives from langchain_openai import ChatOpenAI prompt = RunnableConfigurableAlternatives( which=ConfigurableField(id='prompt'), default=PromptTemplate.from_template("Tell me a joke about {topic}"), default_key='joke', prefix_keys=False, alternatives={"poem":PromptTemplate.from_template("Write a short poem about {topic}")} ) chain = prompt | ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0) chain.with_config(configurable={"prompt": "poem"}).invoke({"topic": "bears"}) rwhichzPdict[str, Union[Runnable[Input, Output], Callable[[], Runnable[Input, Output]]]] alternativesr'r default_keyr, prefix_keysr+rc t5tjx}rnzt jjp jjdtj j gzD}td|tj<dddn #1swxYwYttjjjjjj|j jjgjrfdjjDn jjzfdjDzS)Nc3K|]}||fV dSr<r.rgrs r1rpz@RunnableConfigurableAlternatives.config_specs..3s:Ar3 type[StrEnum]rcXg|]&}t|jjdj'S==)prefix_config_specrrr)rgsr?s r1rizARunnableConfigurableAlternatives.config_specs..GsH'qTZ]*P*Pd>N*P*PQQr3c g|]L\}}t|t|jD]*}jrt |jjd|n|+MSr)rTrrrrrr)rgalt_keyaltrr?s r1rizARunnableConfigurableAlternatives.config_specs..Os    !GSc#788 )   '&qTZ]*G*Gg*G*GHHH    r3)_enums_for_spec_lockrrrrrrrrkeysrrr"rrrrr'rr)r? which_enums` r1rz-RunnableConfigurableAlternatives.config_specs*s" P P,00<<&>!?!?4CSBT!T /3?J.O.O + P P P P P P P P P P P P P P P'&z} $ 6) ,"j2   # /!\6 \.# (     %)$5$;$;$=$=   )    sBB22B69B6rLrr&c ~||j|jjdi||j|j|jS)N)rr'rrrr.)rOrr'rrrrrs r1rz4RunnableConfigurableAlternatives.configurable_fields[sN~~*4DL4>>v>>*((    r3Nr)r(rRc t|}|dijjjjrIt di|dfd|diDi}jkr j|fSj vr2j }t|tr||fS||fSd}t|)Nrrc Xi|]&\}}t|jjdd|'S)r/)_strremoveprefixrr)rgrrr?rs r1rz=RunnableConfigurableAlternatives._prepare..rsN%%% Aq)tz},H,H,H,H,HII1%%%r3zUnknown alternative: ) rrrrrrrrr'rrTr ValueError)r?r)rmsgrs` @r1rUz)RunnableConfigurableAlternatives._preparegs6v&& >2..224:=$BRSS    "%%%%%$*JJ~r$B$B$H$H$J$J%%%  F D$ $ $L&) ) D% % %#E*C#x(( %V}$CEE6? "-e--oor3rrr<r) rrrrrrrrrrrUr.r3r1rrs55nF+ K    NG - - - XX- ^    X  26r3rrrprefixr+c^||r||ddn|S)z4str.removeprefix() is only available in Python 3.9+.r|) startswithreplace)rrs r1rrs.'(||F';'; B199VR # # #Br3rrc|js8t|d|j|j|j|j|j|jn|S)alPrefix the id of a ConfigurableFieldSpec. This is useful when a RunnableConfigurableAlternatives is used as a ConfigurableField of another RunnableConfigurableAlternatives. Args: spec: The ConfigurableFieldSpec to prefix. prefix: The prefix to add. Returns: ConfigurableFieldSpec: The prefixed ConfigurableFieldSpec. rr)rrrrrrr')rrs r1rrs\0~ $$47$$(Ln      r3BUnion[ConfigurableFieldSingleOption, ConfigurableFieldMultiOption]r Optional[str]c >t5t|x}rnbt|jp|jdt |jD}td|t|<dddn #1swxYwYt|tr0t|j|j|j p|||j|jSt|j|j|j p|t ||j|jS)a>Make a ConfigurableFieldSpec for a ConfigurableFieldSingleOption or ConfigurableFieldMultiOption. Args: spec: The ConfigurableFieldSingleOption or ConfigurableFieldMultiOption. description: The description to use if the spec does not have one. Returns: The ConfigurableFieldSpec. c3K|]}||fV dSr<r.rs r1rpz$make_options_spec..s&;;A!Q;;;;;;r3rNr)rrrrrrrrrrrTrrrr'rr)rrenums r1rrst @@"&&t,, ,4 @  $TW;;dl&7&7&9&9!:!:;;;D%)$$?$?OD !@@@@@@@@@@@@@@@$566 $w(7KLn      ! 7 Y$3 D> .    sBBBB)rrrrr+r)rrrrr+r)rrrrr+r)=r __future__rr  threadingabcrcollections.abcrrr functoolsrtypingr r r r r rweakrefrpydanticrrtyping_extensionsrlangchain_core.runnables.baserrlangchain_core.runnables.configrrrrrlangchain_core.runnables.utilsrrrrrrr r!r"langchain_core.runnables.graphr#r%rrEnumrrrLockrrrrrr.r3r1rsi333""""""  ('''''********&&&&&&HHHHHHHH                      5444444IIIII*5&=9IIIXP&P&P&P&P&!?P&P&P&hc49 &y~''`````uf}'E```FCCCC :&&&&&&r3