gh^ dZddlmZddlZddlZddlZddlZddlZddlZddl m Z m Z ddl m Z mZmZmZmZmZmZddlmZmZddlmZddlmZmZdd lmZdd lmZdd lm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*dd l+m,Z,m-Z-m.Z.m/Z/dd l0m1Z1m2Z2m3Z3ddl4m5Z5ddl6m7Z7m8Z8m9Z9ddl:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFddlGmHZHddlImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[ddl\m]Z]m^Z^m_Z_ddl`maZaddlbmcZce r:ddldmeZemfZfddlgmhZhddlimjZkddllmmZmddlnmoZoddlpmqZqddlrmsZsmtZtddlumvZvddlwmxZxe&dZyGd d!e#eNeOfe ZzGd"d#e7ezeNeOfZ{dSd*Z|dSd+Z}Gd,d-e{eNeOfZ~Gd.d/e{eNeee!ffZeZGd0d1ezeNeOfZGd2d3ezeNeOfZGd4d5e{eeNeeOfZGd6d7eeNeOfZGd8d9e{eNeOfZGd:d;eeNeOfZGd<d=e%eNeOfZGd>d?e%eNeOfZGd@dAe%eNeOfZGdBdCe%eNeOfZe'ezeNeOfe"eNgeOfe"eNgeeOfe"eeNgeeOfe"eeNgeeOfeeNeOfeeNeOfeeNeOfeeNeOfeee!ff ZdTdGZe*dUdJZe*dVdLZe*dWdNZe*dXdPZdYdRZdS)Zz)Base classes and utilities for Runnables.) annotationsN)ABCabstractmethod)AsyncGenerator AsyncIterator Awaitable CoroutineIteratorMappingSequence)FIRST_COMPLETEDwait)wraps)groupbytee) itemgetter) GenericAlias) TYPE_CHECKINGAnyCallableGenericOptionalProtocolTypeVarUnioncastget_type_hintsoverload) BaseModel ConfigDictField RootModel)Literalget_argsoverride)beta_decorator) SerializableSerializedConstructorSerializedNotImplemented) RunnableConfigacall_func_with_variable_argscall_func_with_variable_args ensure_config%get_async_callback_manager_for_configget_callback_manager_for_configget_config_listget_executor_for_config merge_configs patch_configrun_in_executorset_config_contextGraph) AddableDictAnyConfigurableFieldConfigurableFieldConfigurableFieldSpecInputOutputaccepts_configaccepts_run_managercoro_with_context gated_corogather_with_concurrency get_function_first_arg_dict_keysget_function_nonlocalsget_lambda_sourceget_unique_config_specsindent_lines_after_firstis_async_callableis_async_generator)aclosingateepy_anext)safetee)create_model_v2)AsyncCallbackManagerForChainRunCallbackManagerForChainRunBasePromptTemplateRunnableWithFallbacks)ExponentialJitterParams) StreamEvent)BaseTool)RunLog RunLogPatch) AsyncListener)RunOtherc eZdZUdZded< ddddd Zedd Zedd ZeddZ dddZ dddZ eddZ dddZ dddZeddZddddZddddZddd Z ddd"Zdd&Zdd)Zdddd,Zdd0Zdd3Z e ddd8Z ddd9Z dd:d;ddCZe dd:d;ddHZe dddKZ dd:d;ddLZ dd:d;ddMZe dd:d;ddOZ e dddQZ dd:d;ddRZ dddTZ! dddVZ"e ddWdWdddddddXddbZ#e ddWdddddddcddeZ# ddWdWdddddddXddgZ# ddhdddddddiddmZ$ dddoZ% dddqZ&ddsZ' dddtZ(dddduddzZ)ddddudd|Z*ddd}ddZ+e,fdWdddddZ-ddZ.e,fddddZ/ dddZ0 dddZ1 dd:ddddZ2 dd:ddddZ3 dddZ4 dddZ5e6j7d dddddddZ8dS)RunnableaA unit of work that can be invoked, batched, streamed, transformed and composed. Key Methods =========== - **invoke/ainvoke**: Transforms a single input into an output. - **batch/abatch**: Efficiently transforms multiple inputs into outputs. - **stream/astream**: Streams output from a single input as it's produced. - **astream_log**: Streams output and selected intermediate results from an input. Built-in optimizations: - **Batch**: By default, batch runs invoke() in parallel using a thread pool executor. Override to optimize batching. - **Async**: Methods with "a" suffix are asynchronous. By default, they execute the sync counterpart using asyncio's thread pool. Override for native async. All methods accept an optional config argument, which can be used to configure execution, add tags and metadata for tracing and debugging etc. Runnables expose schematic information about their input, output and config via the input_schema property, the output_schema property and config_schema method. LCEL and Composition ==================== The LangChain Expression Language (LCEL) is a declarative way to compose Runnables into chains. Any chain constructed this way will automatically have sync, async, batch, and streaming support. The main composition primitives are RunnableSequence and RunnableParallel. **RunnableSequence** invokes a series of runnables sequentially, with one Runnable's output serving as the next's input. Construct using the `|` operator or by passing a list of runnables to RunnableSequence. **RunnableParallel** invokes runnables concurrently, providing the same input to each. Construct it using a dict literal within a sequence or by passing a dict to RunnableParallel. For example, .. code-block:: python from langchain_core.runnables import RunnableLambda # A RunnableSequence constructed using the `|` operator sequence = RunnableLambda(lambda x: x + 1) | RunnableLambda(lambda x: x * 2) sequence.invoke(1) # 4 sequence.batch([1, 2, 3]) # [4, 6, 8] # A sequence that contains a RunnableParallel constructed using a dict literal sequence = RunnableLambda(lambda x: x + 1) | { 'mul_2': RunnableLambda(lambda x: x * 2), 'mul_5': RunnableLambda(lambda x: x * 5) } sequence.invoke(1) # {'mul_2': 4, 'mul_5': 10} Standard Methods ================ All Runnables expose additional methods that can be used to modify their behavior (e.g., add a retry policy, add lifecycle listeners, make them configurable, etc.). These methods will work on any Runnable, including Runnable chains constructed by composing other Runnables. See the individual methods for details. For example, .. code-block:: python from langchain_core.runnables import RunnableLambda import random def add_one(x: int) -> int: return x + 1 def buggy_double(y: int) -> int: """Buggy code that will fail 70% of the time""" if random.random() > 0.3: print('This code failed, and will probably be retried!') # noqa: T201 raise ValueError('Triggered buggy code') return y * 2 sequence = ( RunnableLambda(add_one) | RunnableLambda(buggy_double).with_retry( # Retry on failure stop_after_attempt=10, wait_exponential_jitter=False ) ) print(sequence.input_schema.model_json_schema()) # Show inferred input schema print(sequence.output_schema.model_json_schema()) # Show inferred output schema print(sequence.invoke(2)) # invoke the sequence (note the retry above!!) Debugging and tracing ===================== As the chains get longer, it can be useful to be able to see intermediate results to debug and trace the chain. You can set the global debug flag to True to enable debug output for all chains: .. code-block:: python from langchain_core.globals import set_debug set_debug(True) Alternatively, you can pass existing or custom callbacks to any given chain: .. code-block:: python from langchain_core.tracers import ConsoleCallbackHandler chain.invoke( ..., config={'callbacks': [ConsoleCallbackHandler()]} ) For a UI (and much more) checkout LangSmith: https://docs.smith.langchain.com/ Optional[str]nameNr`suffixreturnstrcv|r|}nft|dr|jr|j}nG|j}t|dr)d|jvr |jd|jdj}n|j}|rK|dr||zS|dz|zS|S)zGet the name of the Runnable.r`__pydantic_generic_metadata__originNr_)hasattrr` __class__rf__name__isuppertitlelower)selfrbr`name_clss Z/var/www/FlaskApp/flask-venv/lib/python3.11/site-packages/langchain_core/runnables/base.pyget_namezRunnable.get_names  %EE T6 " " %ty %IEE.C3 %  AAA5h?K9(CL   0Qx!! .v||~~--3;/ / type[Input]c|jD]F}t|dr4|j}d|vr)t |ddkr|ddcSG|jjD]0}t |}|rt |dkr |dcS1d|d}t|)zGThe type of input this Runnable accepts specified as a type annotation.rfargsr Runnable z` doesn't have an inferable InputType. Override the InputType property to specify the input type. rjmrorirflen__orig_bases__r$rs TypeErrorrobasemetadatarq type_argsmsgs rr InputTypezRunnable.InputTypes N&&(( / /Dt<== /=X%%#hv.>*?*?1*D*D#F+A.... >0 $ $C  I $S^^q00 |### I  I I I nnrt type[Output]c|jD]F}t|dr4|j}d|vr)t |ddkr|ddcSG|jjD]0}t |}|rt |dkr |dcS1d|d}t|)zIThe type of output this Runnable produces specified as a type annotation.rfrwrxryzc doesn't have an inferable OutputType. Override the OutputType property to specify the output type.rzrs rr OutputTypezRunnable.OutputType.s N&&(( / /Dt<== /=X%%#hv.>*?*?1*D*D#F+A....>0 $ $C  I $S^^q00 |### K  K K K nnrttype[BaseModel]c*|S)zFThe type of input this Runnable accepts specified as a pydantic model.)get_input_schemaros rr input_schemazRunnable.input_schemaDs$$&&&rtconfigOptional[RunnableConfig]c|j}tj|r,t|tst |t r|St|d||j j S)aGet a pydantic model that can be used to validate input to the Runnable. Runnables that leverage the configurable_fields and configurable_alternatives methods will have a dynamic input schema that depends on which configuration the Runnable is invoked with. This method allows to get an input schema for a specific configuration. Args: config: A config to use when generating the schema. Returns: A pydantic model that can be used to validate input. r<root module_name) rinspectisclass isinstancer issubclassrrNrsrj __module__ror root_types rrrzRunnable.get_input_schemaIs$N  OI & & y,77 9i00    MM' " "1    rtdict[str, Any]cP||S)aAGet a JSON schema that represents the input to the Runnable. Args: config: A config to use when generating the schema. Returns: A JSON schema that represents the input to the Runnable. Example: .. code-block:: python from langchain_core.runnables import RunnableLambda def add_one(x: int) -> int: return x + 1 runnable = RunnableLambda(add_one) print(runnable.get_input_jsonschema()) .. versionadded:: 0.3.0 )rmodel_json_schemarors rrget_input_jsonschemazRunnable.get_input_jsonschemaqs$4$$V,,>>@@@rtc*|S)zHThe type of output this Runnable produces specified as a pydantic model.)get_output_schemars rr output_schemazRunnable.output_schemas%%'''rtc|j}tj|r,t|tst |t r|St|d||j j S)aGet a pydantic model that can be used to validate output to the Runnable. Runnables that leverage the configurable_fields and configurable_alternatives methods will have a dynamic output schema that depends on which configuration the Runnable is invoked with. This method allows to get an output schema for a specific configuration. Args: config: A config to use when generating the schema. Returns: A pydantic model that can be used to validate output. r=r) rrrrrrrrNrsrjrrs rrrzRunnable.get_output_schemas$O  OI & & y,77 9i00    MM( # #1    rtcP||S)aDGet a JSON schema that represents the output of the Runnable. Args: config: A config to use when generating the schema. Returns: A JSON schema that represents the output of the Runnable. Example: .. code-block:: python from langchain_core.runnables import RunnableLambda def add_one(x: int) -> int: return x + 1 runnable = RunnableLambda(add_one) print(runnable.get_output_jsonschema()) .. versionadded:: 0.3.0 )rrrs rrget_output_jsonschemazRunnable.get_output_jsonschemas$4%%f--??AAArtlist[ConfigurableFieldSpec]cgS)z+List configurable fields for this Runnable.rs rr config_specszRunnable.config_specss  rtincluderOptional[Sequence[str]]cpg|j}|rtdd|Dnd}i|rd|dfinifdttD}t|d|S)asThe type of config this Runnable accepts specified as a pydantic model. To mark a field as configurable, see the `configurable_fields` and `configurable_alternatives` methods. Args: include: A list of fields to include in the config schema. Returns: A pydantic model that can be used to validate config. Configurablec ji|]0}|j|jt|j|j|jf1S))rm description)id annotationr!defaultr`r.0specs rr z*Runnable.config_schema..sV### G L tGW###rtfield_definitionsN configurablec<i|]\}}|dDv||dfS)cg|] }|dk| S)rr)ris rr z5Runnable.config_schema...s"!L!L!L^8K8K!8K8K8KrtNr)r field_name field_typers rrrz*Runnable.config_schema..sH*J !L!LW!L!L!LLLZ.LLLrtConfig)rrNrr*itemsrs)rorrr all_fieldss ` rr config_schemazRunnable.config_schemas-R(  O##!-###     $ 9EMt 4552 .<^.L.L.R.R.T.T t}}X66*UUUUrtcR||S)aGet a JSON schema that represents the config of the Runnable. Args: include: A list of fields to include in the config schema. Returns: A JSON schema that represents the config of the Runnable. .. versionadded:: 0.3.0 r)rr)rors rrget_config_jsonschemazRunnable.get_config_jsonschemas'!!'!22DDFFFrtr7ct} |||}nE#t$r8|t |d}YnwxYw|||r|dnd} |||}nE#t$r8|t |d}YnwxYw|||||||S)z/Return a graph representation of this Runnable.r<rN)rr=) r7add_noderr~rNrsgetradd_edge)rorgraph input_node runnable_node output_nodes rr get_graphzRunnable.get_graphsI Q(=(=f(E(EFFJJ Q Q Q g8N8N(O(OPPJJJ Q VE6::j111'   S..)?)?)G)GHHKK S S S..x9P9P)Q)QRRKKK S z=111 }k222 s!(9?A;:A;-(C?DDlist[BasePromptTemplate]cddlmfd||jDS)z/Return a list of prompts used by this Runnable.rrQcHg|]}t|j|jSr)rdata)rnoderRs rrrz(Runnable.get_prompts...s>   $)%788 I   rt)r)langchain_core.prompts.baserRrnodesvalues)rorrRs @rr get_promptszRunnable.get_prompts(s` CBBBBB    f55;BBDD    rtotherUnion[Runnable[Any, Other], Callable[[Any], Other], Callable[[Iterator[Any]], Iterator[Other]], Mapping[str, Union[Runnable[Any, Other], Callable[[Any], Other], Any]]]"RunnableSerializable[Input, Other]c<t|t|SzGCompose this Runnable with another object to create a RunnableSequence.RunnableSequencecoerce_to_runnablerors rr__or__zRunnable.__or__4s &8&?&?@@@rtUnion[Runnable[Other, Any], Callable[[Other], Any], Callable[[Iterator[Other]], Iterator[Any]], Mapping[str, Union[Runnable[Other, Any], Callable[[Other], Any], Any]]]#RunnableSerializable[Other, Output]c<tt||Srrrs rr__ror__zRunnable.__ror__@s 25 9 94@@@rtothers3Union[Runnable[Any, Other], Callable[[Any], Other]]c"t|g|Rd|iS)aCompose this Runnable with Runnable-like objects to make a RunnableSequence. Equivalent to `RunnableSequence(self, *others)` or `self | others[0] | ...` Example: .. code-block:: python from langchain_core.runnables import RunnableLambda def add_one(x: int) -> int: return x + 1 def mul_two(x: int) -> int: return x * 2 runnable_1 = RunnableLambda(add_one) runnable_2 = RunnableLambda(mul_two) sequence = runnable_1.pipe(runnable_2) # Or equivalently: # sequence = runnable_1 | runnable_2 # sequence = RunnableSequence(first=runnable_1, last=runnable_2) sequence.invoke(1) await sequence.ainvoke(1) # -> 4 sequence.batch([1, 2, 3]) await sequence.abatch([1, 2, 3]) # -> [4, 6, 8] r`)r)ror`rs rrpipez Runnable.pipeLs#D 9v999D999rtkeysUnion[str, list[str]]RunnableSerializable[Any, Any]c*ddlm}|||zS)aPick keys from the output dict of this Runnable. Pick single key: .. code-block:: python import json from langchain_core.runnables import RunnableLambda, RunnableMap as_str = RunnableLambda(str) as_json = RunnableLambda(json.loads) chain = RunnableMap(str=as_str, json=as_json) chain.invoke("[1, 2, 3]") # -> {"str": "[1, 2, 3]", "json": [1, 2, 3]} json_only_chain = chain.pick("json") json_only_chain.invoke("[1, 2, 3]") # -> [1, 2, 3] Pick list of keys: .. code-block:: python from typing import Any import json from langchain_core.runnables import RunnableLambda, RunnableMap as_str = RunnableLambda(str) as_json = RunnableLambda(json.loads) def as_bytes(x: Any) -> bytes: return bytes(x, "utf-8") chain = RunnableMap( str=as_str, json=as_json, bytes=RunnableLambda(as_bytes) ) chain.invoke("[1, 2, 3]") # -> {"str": "[1, 2, 3]", "json": [1, 2, 3], "bytes": b"[1, 2, 3]"} json_and_bytes_chain = chain.pick(["json", "bytes"]) json_and_bytes_chain.invoke("[1, 2, 3]") # -> {"json": [1, 2, 3], "bytes": b"[1, 2, 3]"} r) RunnablePick)$langchain_core.runnables.passthroughr)rorrs rrpickz Runnable.pickps-b FEEEEEll4((((rtkwargsUnion[Runnable[dict[str, Any], Any], Callable[[dict[str, Any]], Any], Mapping[str, Union[Runnable[dict[str, Any], Any], Callable[[dict[str, Any]], Any]]]]c ~ddlm}||tttt f|zS)aAssigns new fields to the dict output of this Runnable. Returns a new Runnable. .. code-block:: python from langchain_community.llms.fake import FakeStreamingListLLM from langchain_core.output_parsers import StrOutputParser from langchain_core.prompts import SystemMessagePromptTemplate from langchain_core.runnables import Runnable from operator import itemgetter prompt = ( SystemMessagePromptTemplate.from_template("You are a nice assistant.") + "{question}" ) llm = FakeStreamingListLLM(responses=["foo-lish"]) chain: Runnable = prompt | llm | {"str": StrOutputParser()} chain_with_assign = chain.assign(hello=itemgetter("str") | llm) print(chain_with_assign.input_schema.model_json_schema()) # {'title': 'PromptInput', 'type': 'object', 'properties': {'question': {'title': 'Question', 'type': 'string'}}} print(chain_with_assign.output_schema.model_json_schema()) # {'title': 'RunnableSequenceOutput', 'type': 'object', 'properties': {'str': {'title': 'Str', 'type': 'string'}, 'hello': {'title': 'Hello', 'type': 'string'}}} r)RunnableAssign)rrRunnableParalleldictrdr)rorrs rrassignzRunnable.assignsCT HGGGGGnn%5d38n%Ef%M%MNNNNrtinputr<rr=c dS)aTransform a single input into an output. Args: input: The input to the Runnable. config: A config to use when invoking the Runnable. The config supports standard keys like 'tags', 'metadata' for tracing purposes, 'max_concurrency' for controlling how much work to do in parallel, and other keys. Please refer to the RunnableConfig for more details. Returns: The output of the Runnable. Nrrorrrs rrinvokezRunnable.invokertc<Kt||j||fi|d{VS)a'Default implementation of ainvoke, calls invoke from a thread. The default implementation allows usage of async code even if the Runnable did not implement a native async version of invoke. Subclasses should override this method if they can run asynchronously. N)r4rrs rrainvokezRunnable.ainvokes8%VT[%RR6RRRRRRRRRrtFreturn_exceptionsinputs list[Input]5Optional[Union[RunnableConfig, list[RunnableConfig]]]rbool Optional[Any] list[Output]c |sgSt|t|}d fd }t|dkr'td ||d |d gSt|d 5}td t ||||cd d d S#1swxYwYd S) aKDefault implementation runs invoke in parallel using a thread pool executor. The default implementation of batch works well for IO bound runnables. Subclasses should override this method if they can batch more efficiently; e.g., if the underlying Runnable uses an API which supports a batch mode. rr<rr*rcUnion[Output, Exception]cxr) j||fiS#t$r }|cYd}~Sd}~wwxYwj||fiSNr Exceptionrrerrros rrrzRunnable.batch..invokesx  <&4;uf????? HHHHHH#t{5&;;F;;;s *%**rrrNrr<rr*rcr )r0r|rr1listmap)rorrrrconfigsrexecutors` `` rrbatchzRunnable.batchs6 I!&#f++66 < < < < < < < < v;;!  q 71:)F)F(GHH H $WQZ 0 0 UHX\\&&'-R-R(S(STT U U U U U U U U U U U U U U U U U Us<2B;;B?B?Sequence[Input]9Optional[Union[RunnableConfig, Sequence[RunnableConfig]]]Literal[False]Iterator[tuple[int, Output]]c dSr rrorrrrs rrbatch_as_completedzRunnable.batch_as_completed (+srt Literal[True].Iterator[tuple[int, Union[Output, Exception]]]c dSr rrs rrrzRunnable.batch_as_completed! :=rtc+| K|sdSt|t|}dfd t|d kr d |d |d VdSt|d 5 fd tt ||D} |rGt |t \}}|r*|V|*|G|D]}| n#|D]}| wxYw ddddS#1swxYwYdS)z^Run invoke in parallel on a list of inputs. Yields results as they complete. Nrintrr<rr*rc$tuple[int, Union[Output, Exception]]cr* j||fi}n(#t$r }|}Yd}~nd}~wwxYwj||fi}||fSr r rrroutrrrros rrrz+Runnable.batch_as_completed..invoke<s! ;4?DKv4X4XQW4X4XCC CCCCCC"dk%::6::s8Os +&+rrcLh|] \}\}}|||!Srsubmit)rrrrrrs rr z.Runnable.batch_as_completed..NsC&Av5&99rt return_whenrr#rr<rr*rcr$) r0r|r1 enumerateziprr popresultcancel) rorrrrrfuturesdonefuturerrs ` `` @@rrrzRunnable.batch_as_completed+s  F!&#f++66         v;;!  &F1Iwqz22 2 2 2 F $WQZ 0 0 $H*3C4H4H*I*IG  $2$(o$N$N$NMD'2"hhjj//1111122 &$$FMMOOOO$g$$FMMOOOO$$ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $s+6+D1"A D+D1D  D11D58D5cK|sgSt|t|}d fd }t|||}t|dd g|Rd {VS) aDefault implementation runs ainvoke in parallel using asyncio.gather. The default implementation of batch works well for IO bound runnables. Subclasses should override this method if they can batch more efficiently; e.g., if the underlying Runnable uses an API which supports a batch mode. Args: inputs: A list of inputs to the Runnable. config: A config to use when invoking the Runnable. The config supports standard keys like 'tags', 'metadata' for tracing purposes, 'max_concurrency' for controlling how much work to do in parallel, and other keys. Please refer to the RunnableConfig for more details. Defaults to None. return_exceptions: Whether to return exceptions instead of raising them. Defaults to False. kwargs: Additional keyword arguments to pass to the Runnable. Returns: A list of outputs from the Runnable. rr<rr*rcr cKr/ j||fid{VS#t$r }|cYd}~Sd}~wwxYwj||fid{VSr rr rs rrrz Runnable.abatch..ainvoke~s! C!-eV!F!Fv!F!FFFFFFFF HHHHHH*T\%BB6BBBBBBBBBs 2-22rmax_concurrencyNr)r0r|rrBr)rorrrrrrcoross` `` rrabatchzRunnable.abatch\s: I!&#f++66 C C C C C C C CGVW--,WQZ^^.ainvoke_tasks! B:F$,v;;)/;;555555CC!CCCCCC)DLAA&AAAAAAAAs8Os 3.3c pg|]2\}\}}rt|||n |||3Sr)rA)rrrrrF semaphores rrrz0Runnable.abatch_as_completed..sf   #?E6 0Jy,,q%"@"@ A A Aa//   rtr.)r0r|rasyncio Semaphorer/r0 as_completed) rorrrrrr:r;cororFrHs ` `` @@rrr?zRunnable.abatch_as_completeds4  F!&#f++66?FP'!*..):;;;D:ISG%o666t              '0FG0D0D&E&E    (//  D******       rtIterator[Output]c+,K|j||fi|VdS)aDefault implementation of stream, which calls invoke. Subclasses should override this method if they support streaming output. Args: input: The input to the Runnable. config: The config to use for the Runnable. Defaults to None. kwargs: Additional keyword arguments to pass to the Runnable. Yields: The output of the Runnable. N)rrs rrstreamzRunnable.streams0$dk%2262222222rtAsyncIterator[Output]c :K|j||fi|d{VWVdS)aDefault implementation of astream, which calls ainvoke. Subclasses should override this method if they support streaming output. Args: input: The input to the Runnable. config: The config to use for the Runnable. Defaults to None. kwargs: Additional keyword arguments to pass to the Runnable. Yields: The output of the Runnable. N)rrs rrastreamzRunnable.astreamsE$!DL99&99999999999999rtT)diffwith_streamed_output_list include_names include_types include_tags exclude_names exclude_types exclude_tagsrSrTrUrVrWrXrYrZAsyncIterator[RunLogPatch]c dSr r rorrrSrTrUrVrWrXrYrZrs rr astream_logzRunnable.astream_logs &)Srt)rTrUrVrWrXrYrZAsyncIterator[RunLog]c dSr rr]s rrr^zRunnable.astream_logs !$rt8Union[AsyncIterator[RunLogPatch], AsyncIterator[RunLog]]c zKddlm} m} | d||||| | d}| |||f|||d| 23d{V}|WV 6dS)aStream all output from a Runnable, as reported to the callback system. This includes all inner runs of LLMs, Retrievers, Tools, etc. Output is streamed as Log objects, which include a list of Jsonpatch ops that describe how the state of the run has changed in each step, and the final state of the run. The Jsonpatch ops can be applied in order to construct state. Args: input: The input to the Runnable. config: The config to use for the Runnable. diff: Whether to yield diffs between each step or the current state. with_streamed_output_list: Whether to yield the streamed_output list. include_names: Only include logs with these names. include_types: Only include logs with these types. include_tags: Only include logs with these tags. exclude_names: Exclude logs with these names. exclude_types: Exclude logs with these types. exclude_tags: Exclude logs with these tags. kwargs: Additional keyword arguments to pass to the Runnable. Yields: A RunLogPatch or RunLog object. r)LogStreamCallbackHandler_astream_log_implementationForiginal) auto_closerUrVrWrXrYrZ_schema_format)rSrOrTN)!langchain_core.tracers.log_streamrcrd)rorrrSrTrUrVrWrXrYrZrrcrdrOitems rrr^zRunnable.astream_log$sR        *)''%''%%    65    &?           $JJJJJ   s:v2)versionrUrVrWrXrYrZrkLiteral['v1', 'v2']AsyncIterator[StreamEvent]c 6Kddlm} m} |dkr| ||f||||||| d| } n*|dkr| ||f||||||| d| } nd}t|t | 4d{V| 23d{V}|WV 6 dddd{VdS#1d{VswxYwYdS)as5Generate a stream of events. Use to create an iterator over StreamEvents that provide real-time information about the progress of the Runnable, including StreamEvents from intermediate results. A StreamEvent is a dictionary with the following schema: - ``event``: **str** - Event names are of the format: on_[runnable_type]_(start|stream|end). - ``name``: **str** - The name of the Runnable that generated the event. - ``run_id``: **str** - randomly generated ID associated with the given execution of the Runnable that emitted the event. A child Runnable that gets invoked as part of the execution of a parent Runnable is assigned its own unique ID. - ``parent_ids``: **list[str]** - The IDs of the parent runnables that generated the event. The root Runnable will have an empty list. The order of the parent IDs is from the root to the immediate parent. Only available for v2 version of the API. The v1 version of the API will return an empty list. - ``tags``: **Optional[list[str]]** - The tags of the Runnable that generated the event. - ``metadata``: **Optional[dict[str, Any]]** - The metadata of the Runnable that generated the event. - ``data``: **dict[str, Any]** Below is a table that illustrates some events that might be emitted by various chains. Metadata fields have been omitted from the table for brevity. Chain definitions have been included after the table. **ATTENTION** This reference table is for the V2 version of the schema. +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | event | name | chunk | input | output | +======================+==================+=================================+===============================================+=================================================+ | on_chat_model_start | [model name] | | {"messages": [[SystemMessage, HumanMessage]]} | | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_chat_model_stream | [model name] | AIMessageChunk(content="hello") | | | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_chat_model_end | [model name] | | {"messages": [[SystemMessage, HumanMessage]]} | AIMessageChunk(content="hello world") | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_llm_start | [model name] | | {'input': 'hello'} | | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_llm_stream | [model name] | 'Hello' | | | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_llm_end | [model name] | | 'Hello human!' | | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_chain_start | format_docs | | | | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_chain_stream | format_docs | "hello world!, goodbye world!" | | | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_chain_end | format_docs | | [Document(...)] | "hello world!, goodbye world!" | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_tool_start | some_tool | | {"x": 1, "y": "2"} | | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_tool_end | some_tool | | | {"x": 1, "y": "2"} | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_retriever_start | [retriever name] | | {"query": "hello"} | | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_retriever_end | [retriever name] | | {"query": "hello"} | [Document(...), ..] | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_prompt_start | [template_name] | | {"question": "hello"} | | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ | on_prompt_end | [template_name] | | {"question": "hello"} | ChatPromptValue(messages: [SystemMessage, ...]) | +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+ In addition to the standard events, users can also dispatch custom events (see example below). Custom events will be only be surfaced with in the `v2` version of the API! A custom event has following format: +-----------+------+-----------------------------------------------------------------------------------------------------------+ | Attribute | Type | Description | +===========+======+===========================================================================================================+ | name | str | A user defined name for the event. | +-----------+------+-----------------------------------------------------------------------------------------------------------+ | data | Any | The data associated with the event. This can be anything, though we suggest making it JSON serializable. | +-----------+------+-----------------------------------------------------------------------------------------------------------+ Here are declarations associated with the standard events shown above: `format_docs`: .. code-block:: python def format_docs(docs: list[Document]) -> str: '''Format the docs.''' return ", ".join([doc.page_content for doc in docs]) format_docs = RunnableLambda(format_docs) `some_tool`: .. code-block:: python @tool def some_tool(x: int, y: str) -> dict: '''Some_tool.''' return {"x": x, "y": y} `prompt`: .. code-block:: python template = ChatPromptTemplate.from_messages( [("system", "You are Cat Agent 007"), ("human", "{question}")] ).with_config({"run_name": "my_template", "tags": ["my_template"]}) Example: .. code-block:: python from langchain_core.runnables import RunnableLambda async def reverse(s: str) -> str: return s[::-1] chain = RunnableLambda(func=reverse) events = [ event async for event in chain.astream_events("hello", version="v2") ] # will produce the following events (run_id, and parent_ids # has been omitted for brevity): [ { "data": {"input": "hello"}, "event": "on_chain_start", "metadata": {}, "name": "reverse", "tags": [], }, { "data": {"chunk": "olleh"}, "event": "on_chain_stream", "metadata": {}, "name": "reverse", "tags": [], }, { "data": {"output": "olleh"}, "event": "on_chain_end", "metadata": {}, "name": "reverse", "tags": [], }, ] Example: Dispatch Custom Event .. code-block:: python from langchain_core.callbacks.manager import ( adispatch_custom_event, ) from langchain_core.runnables import RunnableLambda, RunnableConfig import asyncio async def slow_thing(some_input: str, config: RunnableConfig) -> str: """Do something that takes a long time.""" await asyncio.sleep(1) # Placeholder for some slow operation await adispatch_custom_event( "progress_event", {"message": "Finished step 1 of 3"}, config=config # Must be included for python < 3.10 ) await asyncio.sleep(1) # Placeholder for some slow operation await adispatch_custom_event( "progress_event", {"message": "Finished step 2 of 3"}, config=config # Must be included for python < 3.10 ) await asyncio.sleep(1) # Placeholder for some slow operation return "Done" slow_thing = RunnableLambda(slow_thing) async for event in slow_thing.astream_events("some_input", version="v2"): print(event) Args: input: The input to the Runnable. config: The config to use for the Runnable. version: The version of the schema to use either `v2` or `v1`. Users should use `v2`. `v1` is for backwards compatibility and will be deprecated in 0.4.0. No default will be assigned until the API is stabilized. custom events will only be surfaced in `v2`. include_names: Only include events from runnables with matching names. include_types: Only include events from runnables with matching types. include_tags: Only include events from runnables with matching tags. exclude_names: Exclude events from runnables with matching names. exclude_types: Exclude events from runnables with matching types. exclude_tags: Exclude events from runnables with matching tags. kwargs: Additional keyword arguments to pass to the Runnable. These will be passed to astream_log as this implementation of astream_events is built on top of astream_log. Yields: An async stream of StreamEvents. Raises: NotImplementedError: If the version is not `v1` or `v2`. r)!_astream_events_implementation_v1!_astream_events_implementation_v2rj)rrUrVrWrXrYrZv1zAOnly versions "v1" and "v2" of the schema is currently supported.N)#langchain_core.tracers.event_streamrorpNotImplementedErrorrJ)rorrrkrUrVrWrXrYrZrrorp event_streamrevents rrastream_eventszRunnable.astream_eventsksB        d??<< ++)++)    LL__=< ++)++)    LLVC%c** *L))        +       e  ,|                              s#B&A3,B BBIterator[Input]c+Kd}|D]!}|s|}d} ||z}#t$r|}YwxYw|r|j||fi|Ed{VdSdS)aDefault implementation of transform, which buffers input and calls astream. Subclasses should override this method if they can start producing output while input is still being generated. Args: input: An iterator of inputs to the Runnable. config: The config to use for the Runnable. Defaults to None. kwargs: Additional keyword arguments to pass to the Runnable. Yields: The output of the Runnable. FTN)r~rO)rorrr got_first_valichunkfinals rr transformzRunnable.transformus(  # #F! # $ #!FNEE ###"EEE#  <"t{5&;;F;; ; ; ; ; ; ; ; ; ; < z)Runnable.with_listeners..Hs3++#)%-#)%- " rtrconfig_factories)%langchain_core.tracers.root_listenersrr)rorrrrs ```@rrwith_listenerszRunnable.with_listeners s^n NMMMMM            rtOptional[AsyncListener]cFddlmt|fdgS)a Bind async lifecycle listeners to a Runnable, returning a new Runnable. on_start: Asynchronously called before the Runnable starts running. on_end: Asynchronously called after the Runnable finishes running. on_error: Asynchronously called if the Runnable throws an error. The Run object contains information about the run, including its id, type, input, output, error, start_time, end_time, and any tags or metadata added to the run. Args: on_start: Asynchronously called before the Runnable starts running. Defaults to None. on_end: Asynchronously called after the Runnable finishes running. Defaults to None. on_error: Asynchronously called if the Runnable throws an error. Defaults to None. Returns: A new Runnable with the listeners bound. Example: .. code-block:: python from langchain_core.runnables import RunnableLambda, Runnable from datetime import datetime, timezone import time import asyncio def format_t(timestamp: float) -> str: return datetime.fromtimestamp(timestamp, tz=timezone.utc).isoformat() async def test_runnable(time_to_sleep : int): print(f"Runnable[{time_to_sleep}s]: starts at {format_t(time.time())}") await asyncio.sleep(time_to_sleep) print(f"Runnable[{time_to_sleep}s]: ends at {format_t(time.time())}") async def fn_start(run_obj : Runnable): print(f"on start callback starts at {format_t(time.time())}") await asyncio.sleep(3) print(f"on start callback ends at {format_t(time.time())}") async def fn_end(run_obj : Runnable): print(f"on end callback starts at {format_t(time.time())}") await asyncio.sleep(2) print(f"on end callback ends at {format_t(time.time())}") runnable = RunnableLambda(test_runnable).with_alisteners( on_start=fn_start, on_end=fn_end ) async def concurrent_runs(): await asyncio.gather(runnable.ainvoke(2), runnable.ainvoke(3)) asyncio.run(concurrent_runs()) Result: on start callback starts at 2025-03-01T07:05:22.875378+00:00 on start callback starts at 2025-03-01T07:05:22.875495+00:00 on start callback ends at 2025-03-01T07:05:25.878862+00:00 on start callback ends at 2025-03-01T07:05:25.878947+00:00 Runnable[2s]: starts at 2025-03-01T07:05:25.879392+00:00 Runnable[3s]: starts at 2025-03-01T07:05:25.879804+00:00 Runnable[2s]: ends at 2025-03-01T07:05:27.881998+00:00 on end callback starts at 2025-03-01T07:05:27.882360+00:00 Runnable[3s]: ends at 2025-03-01T07:05:28.881737+00:00 on end callback starts at 2025-03-01T07:05:28.882428+00:00 on end callback ends at 2025-03-01T07:05:29.883893+00:00 on end callback ends at 2025-03-01T07:05:30.884831+00:00 r)AsyncRootListenersTracerc(d|giSrr)rrrrrs rrrz*Runnable.with_alisteners..s300#)%-#)%- " rtr)rrr)rorrrrs ```@rrwith_alistenerszRunnable.with_alistenersUs^\ SRRRRR            rt) input_type output_typerOptional[type[Input]]rOptional[type[Output]]c(t|||iS)aEBind input and output types to a Runnable, returning a new Runnable. Args: input_type: The input type to bind to the Runnable. Defaults to None. output_type: The output type to bind to the Runnable. Defaults to None. Returns: A new Runnable with the types bound. )rcustom_input_typecustom_output_typerrrorrs rr with_typeszRunnable.with_typess'(*     rt)retry_if_exception_typewait_exponential_jitterexponential_jitter_paramsstop_after_attemptrtuple[type[BaseException], ...]rr!Optional[ExponentialJitterParams]rr#c 2ddlm}||ii||||S)aCreate a new Runnable that retries the original Runnable on exceptions. Args: retry_if_exception_type: A tuple of exception types to retry on. Defaults to (Exception,). wait_exponential_jitter: Whether to add jitter to the wait time between retries. Defaults to True. stop_after_attempt: The maximum number of attempts to make before giving up. Defaults to 3. exponential_jitter_params: Parameters for ``tenacity.wait_exponential_jitter``. Namely: ``initial``, ``max``, ``exp_base``, and ``jitter`` (all float values). Returns: A new Runnable that retries the original Runnable on exceptions. Example: .. code-block:: python from langchain_core.runnables import RunnableLambda count = 0 def _lambda(x: int) -> None: global count count = count + 1 if x == 1: raise ValueError("x is 1") else: pass runnable = RunnableLambda(_lambda) try: runnable.with_retry( stop_after_attempt=2, retry_if_exception_type=(ValueError,), ).invoke(1) except ValueError: pass assert (count == 2) r) RunnableRetry)rrrretry_exception_typesrmax_attempt_numberr)langchain_core.runnables.retryr)rorrrrrs rr with_retryzRunnable.with_retrysFl A@@@@@}"9$;1&?    rt#Runnable[list[Input], list[Output]]c"t|S)a+Return a new Runnable that maps a list of inputs to a list of outputs. Calls invoke() with each input. Returns: A new Runnable that maps a list of inputs to a list of outputs. Example: .. code-block:: python from langchain_core.runnables import RunnableLambda def _lambda(x: int) -> int: return x + 1 runnable = RunnableLambda(_lambda) print(runnable.map().invoke([1, 2, 3])) # [2, 3, 4] r) RunnableEachrs rrrz Runnable.map s($''''rt)exceptions_to_handle exception_key fallbacks!Sequence[Runnable[Input, Output]]rr%RunnableWithFallbacksT[Input, Output]c,ddlm}|||||S)aAdd fallbacks to a Runnable, returning a new Runnable. The new Runnable will try the original Runnable, and then each fallback in order, upon failures. Args: fallbacks: A sequence of runnables to try if the original Runnable fails. exceptions_to_handle: A tuple of exception types to handle. Defaults to (Exception,). exception_key: If string is specified then handled exceptions will be passed to fallbacks as part of the input under the specified key. If None, exceptions will not be passed to fallbacks. If used, the base Runnable and its fallbacks must accept a dictionary as input. Defaults to None. Returns: A new Runnable that will try the original Runnable, and then each fallback in order, upon failures. Example: .. code-block:: python from typing import Iterator from langchain_core.runnables import RunnableGenerator def _generate_immediate_error(input: Iterator) -> Iterator[str]: raise ValueError() yield "" def _generate(input: Iterator) -> Iterator[str]: yield from "foo bar" runnable = RunnableGenerator(_generate_immediate_error).with_fallbacks( [RunnableGenerator(_generate)] ) print(''.join(runnable.stream({}))) #foo bar Args: fallbacks: A sequence of runnables to try if the original Runnable fails. exceptions_to_handle: A tuple of exception types to handle. exception_key: If string is specified then handled exceptions will be passed to fallbacks as part of the input under the specified key. If None, exceptions will not be passed to fallbacks. If used, the base Runnable and its fallbacks must accept a dictionary as input. Returns: A new Runnable that will try the original Runnable, and then each fallback in order, upon failures. rrS)runnablerrr)"langchain_core.runnables.fallbacksrT)rorrrrTs rrwith_fallbackszRunnable.with_fallbacks#s>z MLLLLL$$!5'     rtfuncUnion[Callable[[Input], Output], Callable[[Input, CallbackManagerForChainRun], Output], Callable[[Input, CallbackManagerForChainRun, RunnableConfig], Output]]run_type serializedOptional[dict[str, Any]]c Ft|}t|}|||||dp||dd} t ||} t| 5} td| j t||||fi|} dddn #1swxYwY| | | S#t$r} || d} ~ wwxYw)zHelper method to transform an Input value to an Output value, with callbacks. Use this method to implement invoke() in subclasses. run_namerun_idNrr`rrr=)r-r/on_chain_startrrsr1r3 get_childr5rrunr, on_chain_end BaseExceptionon_chain_error) rorrrrrrcallback_manager run_manager child_configcontextrrs rr_call_with_configzRunnable._call_with_configks"v&&:6BB&55  J'':4==??::h-- 6   '+:O:O:Q:QRRRL#L11 WGK4#  !                    $ $V , , ,M      & &q ) ) )  s<52C;'&C C;CC; C!C;; D DD Union[Callable[[Input], Awaitable[Output]], Callable[[Input, AsyncCallbackManagerForChainRun], Awaitable[Output]], Callable[[Input, AsyncCallbackManagerForChainRun, RunnableConfig], Awaitable[Output]]]c pKt|}t|}|||||dp||ddd{V} t ||} t| 5} t||||fi|} t| | d{V} dddn #1swxYwY| | d{V| S#t$r!} | | d{Vd} ~ wwxYw)zHelper method to transform an Input value to an Output value, with callbacks. Use this method to implement ainvoke() in subclasses. rrNrr)r-r.rrrsr1r3rr5r+r@rrr)rorrrrrrrrrrrLrrs rr_acall_with_configzRunnable._acall_with_configs(v&&@HH,;;  J'':4==??::h-- <         '+:O:O:Q:QRRRL#L11 HW4%8>(9w'G'G!G!G!G!G!G!G  H H H H H H H H H H H H H H H**622 2 2 2 2 2 2 2M    ,,Q// / / / / / / /  s<=2D /'C" D "C&&D )C&*D D5D00D5)rr Union[Callable[[list[Input]], list[Union[Exception, Output]]], Callable[[list[Input], list[CallbackManagerForChainRun]], list[Union[Exception, Output]]], Callable[[list[Input], list[CallbackManagerForChainRun], list[RunnableConfig]], list[Union[Exception, Output]]]]c |sgSt|t|}d|D}fdt|||D} t|rdt|| D|d<t |r| |d<||fi|} d} t| | D]I\} } t | t r| p| } | | 4| | J|s| td| S| #t$rC| D]} | |r!tdfd|DcYdSdwwxYw) zTransform a list of inputs to a list of outputs, with callbacks. Helper method to transform an Input value to an Output value, with callbacks. Use this method to implement invoke() in subclasses. c,g|]}t|Sr)r/rcs rrrz/Runnable._batch_with_config..s!QQQA.s}    0 %  + +!ZZ ++>t}}zz(D11 ,      rtcZg|](\}}t||)Srr3rrrrms rrrz/Runnable._batch_with_config..A$$$2!bllnn===$$$rtrrNrcg|]}Srrrrhrs rrrz/Runnable._batch_with_config..,>,>,>1Q,>,>,>rt) r0r|r0r>r?rr rrrr)rorrrrrrrcallback_managers run_managersrfirst_exceptionrr'rs` ` @rr_batch_with_configzRunnable._batch_with_configs 2 I!&#e**55QQQQQ      47!5'44     "d## $$!$Wl!;!;$$$x #4(( 5(4}%T%**6**F48O$' f$=$= 2 2 Sc9--2&5&<O..s3333,,S1111  4O$;NF333! !!   + . . **1----  @N,>,>,>,>,>,>,>????????   s%A D E7E EEE5Union[Callable[[list[Input]], Awaitable[list[Union[Exception, Output]]]], Callable[[list[Input], list[AsyncCallbackManagerForChainRun]], Awaitable[list[Union[Exception, Output]]]], Callable[[list[Input], list[AsyncCallbackManagerForChainRun], list[RunnableConfig]], Awaitable[list[Union[Exception, Output]]]]]cnK|sgSt|t|}d|D}tjfdt |||Dd{V} t |rdt || D|d<t |r| |d<||fi|d{V} d} g} t | | D]o\} }t|tr-| p|} | | |G| | |ptj| d{V|s| td| S| #t$rItjfd| Dd{V|r!tdfd |DcYdSdwwxYw) zTransform a list of inputs to a list of outputs, with callbacks. Helper method to transform an Input value to an Output value, with callbacks. Use this method to implement invoke() in subclasses. c,g|]}t|Sr)r.rs rrrz0Runnable._abatch_with_config..,s!WWW!B1EEWWWrtc 3K|]]\}}}|d||dp|ddV^dSrrrs rr z/Runnable._abatch_with_config...s  4$eV!//%J//B4==??!::h55 0      rtNcZg|](\}}t||)Srrrs rrrz0Runnable._abatch_with_config..=rrtrrrc3BK|]}|VdSr r)rrrs rrrz/Runnable._abatch_with_config..Fs1PPK+,,Q//PPPPPPrtcg|]}Srrrs rrrz0Runnable._abatch_with_config..Irrt)r0r|rIgatherr0r>r?rr appendrrrr)rorrrrrrrrrrrr;rr'rs` ` @rr_abatch_with_configzRunnable._abatch_with_config s< I!&#e**55WWwWWWDKN     8;%ug88    E ? ? ? ? ? ?  "d## $$!$Wl!;!;$$$x #4(( 5(4}%40000000000F48O+-E$' f$=$= @ @ Sc9--@&5&<OLL!;!;C!@!@AAAALL!9!9#!>!>????.%( ( ( ( ( ( ( (  4O$;NF333! !'   .PPPP<PPP       ! @N,>,>,>,>,>,>,>????????   s%$AE!! F4+=F/(F4.F//F4 transformerUnion[Callable[[Iterator[Input]], Iterator[Output]], Callable[[Iterator[Input], CallbackManagerForChainRun], Iterator[Output]], Callable[[Iterator[Input], CallbackManagerForChainRun, RunnableConfig], Iterator[Output]]]c +dKddlmt|d\}}t|d}d} d} d} t |}t |} | dddi||dp|| d d } t|| }t|r||d <t|r| |d <t|5}|j||fi|}tfd| jDdx}r|| j|} |t|}|V| r | |} n | |z} n#t&$r|} d} YnwxYw|} D#t(t*f$rYnwxYw|D]&}| r ||} ||z}#t&$r|}d} Y wxYw|}' dddn #1swxYwY| | |dS#t.$r}| ||d}~wwxYw)zTransform a stream with config. Helper method to transform an Iterator of Input values into an Iterator of Output values, with callbacks. Use this to implement `stream()` or `transform()` in Runnable subclasses. r_StreamingCallbackHandlerrxNTrrrrrrrc3XK|]$}t|td|V%dSrNrrrhrs rrrz9Runnable._transform_stream_with_config..S%a)BCC 8!<<rtFr)!langchain_core.tracers._streamingrrnextr-r/rrrsr1r3rr>r?r5rhandlerstap_output_iterrr~ StopIteration GeneratorExitrrr)rorrrrrinput_for_tracinginput_for_transform final_inputfinal_input_supported final_outputfinal_output_supportedrrrriteratorstream_handlerchunkrzrrs @rr_transform_stream_with_configz&Runnable._transform_stream_with_configYs{4 POOOOO25UA..'+,=t'D'D $)- !%v&&:6BB&55  bMJ'':4==??::h-- 6  6 G'+:O:O:Q:QRRRLk** 0#/x ";// 4(3}%#L11+ -W&7;{4GRR6RR%)!,!5 &&>  .==#*H  H 1(/ D((C(C# 1 1+3/4 !C3?%3GLL'0!C!C!C38L=B$:$:$:!C,1L 1&}5D/ - -F, -&.*0KK>.9F.B #,>>>.4 8= 5 5 5>'-  -A+ -+ -+ -+ -+ -+ -+ -+ -+ -+ -+ -+ -+ -+ -+ -`  $ $\+ $ F F F F F      & &q & = = =  s)AHAG$'F:F?FFFFFF+(G$*F++G$:G?G$GG$GG$ H$G((H+G(,H H/H**H/Union[Callable[[AsyncIterator[Input]], AsyncIterator[Output]], Callable[[AsyncIterator[Input], AsyncCallbackManagerForChainRun], AsyncIterator[Output]], Callable[[AsyncIterator[Input], AsyncCallbackManagerForChainRun, RunnableConfig], AsyncIterator[Output]]]c tKddlmt|d\}}t|dd{V}d} d} d} t |}t |} | dddi||dp|| d d d{V} t|| }t|r||d <t|r| |d <t|5}|j||fi|}t!fd| jDdx}r|| j|}n|} t)t||d{V}|WV| r | |} n | |z} n#t*$r|} d} YnwxYw|} M#t,$rYnwxYw|23d{V}| r ||} ||z}#t*$r|}d} Y%wxYw|},6 dddn #1swxYwY| | |d{Vn0#t0$r#}| ||d{Vd}~wwxYw |,t5|dr|d{VdSdSdS#|+t5|dr|d{VwwwxYw)aTransform a stream with config. Helper method to transform an Async Iterator of Input values into an Async Iterator of Output values, with callbacks. Use this to implement `astream()` or `atransform()` in Runnable subclasses. rrrxNTrrrrrrrrc3XK|]$}t|td|V%dSrrrs rrrz:Runnable._atransform_stream_with_config..r rtFr aclose)r rrKrLr-r.rrrsr1r3rr>r?r5rr r tap_output_aiterrr@r~StopAsyncIterationrrrrir)rorrrrrrrrrrrrrrr iterator_rrrrzrrs @rr_atransform_stream_with_configz'Runnable._atransform_stream_with_configs: POOOOO26eQ..-56G-N-N'N'N'N'N'N'N $)- !%v&&@HH,;;  bMJ'':4==??::h-- <        < )'+:O:O:Q:QRRRLk** 0#/x ";// 4(3}%#L11. -W'GK 5HSSFSS %)!,!5 &&>) .>>#*I  HH )H 1&78J8JG&T&T T T T T T T# 1 1+3/4 !C3?%3GLL'0!C!C!C38L=B$:$:$:!C,1L 1*D$5 - - - - - - -&, -&.*0KK>.9F.B #,>>>.4 8= 5 5 5>'- %6$5G. -. -. -. -. -. -. -. -. -. -. -. -. -. -. -f**< *LL L L L L L L L L    ,,Q{,CC C C C C C C C   M$H)E)E$&&(((((((((((%$$$y$H)E)E$&&((((((((((%$s5AH$AG;!0F/FF/F)&F/(F))F// F<9G;;F<<G;G-G;GG;G'$G;&G''G;/ H$;G??H$G?H$J$ I.I  IJ0J7z1This API is in beta and may change in the future.)message)r`r arg_types args_schemaOptional[type[BaseModel]]rr$Optional[dict[str, type]]rWc.ddlm}||||||S)au Create a BaseTool from a Runnable. ``as_tool`` will instantiate a BaseTool with a name, description, and ``args_schema`` from a Runnable. Where possible, schemas are inferred from ``runnable.get_input_schema``. Alternatively (e.g., if the Runnable takes a dict as input and the specific dict keys are not typed), the schema can be specified directly with ``args_schema``. You can also pass ``arg_types`` to just specify the required arguments and their types. Args: args_schema: The schema for the tool. Defaults to None. name: The name of the tool. Defaults to None. description: The description of the tool. Defaults to None. arg_types: A dictionary of argument names to types. Defaults to None. Returns: A BaseTool instance. Typed dict input: .. code-block:: python from typing_extensions import TypedDict from langchain_core.runnables import RunnableLambda class Args(TypedDict): a: int b: list[int] def f(x: Args) -> str: return str(x["a"] * max(x["b"])) runnable = RunnableLambda(f) as_tool = runnable.as_tool() as_tool.invoke({"a": 3, "b": [1, 2]}) ``dict`` input, specifying schema via ``args_schema``: .. code-block:: python from typing import Any from pydantic import BaseModel, Field from langchain_core.runnables import RunnableLambda def f(x: dict[str, Any]) -> str: return str(x["a"] * max(x["b"])) class FSchema(BaseModel): """Apply a function to an integer and list of integers.""" a: int = Field(..., description="Integer") b: list[int] = Field(..., description="List of ints") runnable = RunnableLambda(f) as_tool = runnable.as_tool(FSchema) as_tool.invoke({"a": 3, "b": [1, 2]}) ``dict`` input, specifying schema via ``arg_types``: .. code-block:: python from typing import Any from langchain_core.runnables import RunnableLambda def f(x: dict[str, Any]) -> str: return str(x["a"] * max(x["b"])) runnable = RunnableLambda(f) as_tool = runnable.as_tool(arg_types={"a": int, "b": list[int]}) as_tool.invoke({"a": 3, "b": [1, 2]}) String input: .. code-block:: python from langchain_core.runnables import RunnableLambda def f(x: str) -> str: return x + "a" def g(x: str) -> str: return x + "z" runnable = RunnableLambda(f) | g as_tool = runnable.as_tool() as_tool.invoke("b") .. versionadded:: 0.2.14 r)convert_runnable_to_tool)r%r`rr$)langchain_core.toolsr))ror%r`rr$r)s rras_toolzRunnable.as_tool, sAF BAAAAA'' ##     rtr rbr_r`r_rcrdrcrurcr)rcrrrrcr)rrrcrrcr)rrrcr)rrrcrrrrcr7)rrrcrrrrcrrrrcr)rrr`r_rcr)rrrcr)rrrcrrr<rrrrrcr= rrrrrrrrrcr rrrrrrrrrcr rrrrrrrrrcr rrrrrrrrrcr rrrrrrrrrcr= rrrrrrrrrcrA rrrrrrrrrcrArr<rrrrrcrMrr<rrrrrcrP)rrrrrSrrTrrUrrVrrWrrXrrYrrZrrrrcr[)rrrrrSrrTrrUrrVrrWrrXrrYrrZrrrrcr_)rrrrrSrrTrrUrrVrrWrrXrrYrrZrrrrcra)rrrrrkrlrUrrVrrWrrXrrYrrZrrrrcrmrrwrrrrrcrMrr}rrrrrcrPrrrcrrrrrrcrrrrrrrrcr)rrrrrrrcr)rrrrrcr) rrrrrrrr#rcr)rcr)rrrrrr_rcrNN)rrrr<rrrr_rrrrrcr=)rrrr<rrrr_rrrrrcr=)rrrrrrrrrr_rrrcr)rrrrrrrrrr_rrrcr) rrwrrrrrr_rrrcrM) rr}rrrrrr_rrrcrP) r%r&r`r_rr_r$r'rcrW)9rkr __qualname____doc____annotations__rspropertyrrrrrrrrrrrrrrrrrrrrrrrrr<r?rOrRr^rvr|rrrrrrr rrrrrrrrr"r&betar+rrtrrr^r^osBC'+EI@X2X*'''X' ,0& & & & & R26AAAAA8(((X( ,0& & & & & R26BBBBB8X 59*V*V*V*V*V*VZ59 G G G G G G&26       A A A A A A A A#":":":":":":H3)3)3)3)j,O,O,O,O\?C    ^ $@D S S S S SIM"U #( "U"U"U"U"U"UHMQ+ -2 +++++X+MQ====X=MQ/$ #( /$/$/$/$/$/$hIM.X #( .X.X.X.X.X.X`MQ0 -2 00000X0MQBBBBXBMQ8 #( 888888z,033333.,0:::::(,0) #*.151504151504)))))X) ,0$ +/151504151504$$$$$X$&,0E *.151504151504EEEEEET,0H (,151504151504HHHHHHZ,0(<(<(<(<(., sB###1 444 ai0444rtr) rrrr|rr_seq_input_schemarr"rNrYr)rhrrrnext_input_schemarrs @rrrsrs sRQQQQQQQ !HE 5zzQ%%f---%(( 4-eABBi@@+Y77 "'#### 1 > D D F F###   E< ( (4 qrrF333  ! !& ) ))rtcpddlm}m}|dt|dkr|St |rj|}t|dd|}t|tsWtdid|j Dd|j DSnt |rt|dd|}t|ts}t jtr4tdfd |j DS|j j}td|j|jf S|S) NrrkrRunnableSequenceOutputc2i|]\}}||j|jfSrrrrrprqs rrrz&_seq_output_schema..H 7 AqAL!)4rtc2i|]\}}||j|jfSrryrzs rrrz&_seq_output_schema..L r{rtrcFi|]\}}|jv||j|jfSr)rrr)rrprqlasts rrrz&_seq_output_schema..Y s;''' Aq >>AL!)4)>>rt)r)rrrr|rrrnr_seq_output_schemarr"rNrYrrrrr)rhrrrmapper_output_schemaprev_output_schemafieldr~s @rrrr8 sRQQQQQQQ 9D 5zzQ$$V,,,$''"#{<E"(0@%-/P   ! !& ) ))rtceZdZUdZded< eeZded< ded< d d d d d dPfdZe e dQdZ e dRdZ e e dSdZedZe e dTdZe e dUdZe dVdWd"Ze dVdWd#Ze e dXd%Ze dVdYd'Ze dZd)Ze d[d-Ze d\d0Ze dVd]d6Ze dVd^d8Ze dVd9d:d_d@Ze dVd9d:d_dAZd`dGZdadKZe dVdbdLZ e dVdcdMZ!e dVdddNZ"e dVdedOZ#xZ$S)fra] Sequence of Runnables, where the output of each is the input of the next. **RunnableSequence** is the most important composition operator in LangChain as it is used in virtually every chain. A RunnableSequence can be instantiated directly or more commonly by using the `|` operator where either the left or right operands (or both) must be a Runnable. Any RunnableSequence automatically supports sync, async, batch. The default implementations of `batch` and `abatch` utilize threadpools and asyncio gather and will be faster than naive invocation of invoke or ainvoke for IO bound Runnables. Batching is implemented by invoking the batch method on each component of the RunnableSequence in order. A RunnableSequence preserves the streaming properties of its components, so if all components of the sequence implement a `transform` method -- which is the method that implements the logic to map a streaming input to a streaming output -- then the sequence will be able to stream input to output! If any component of the sequence does not implement transform then the streaming will only begin after this component is run. If there are multiple blocking components, streaming begins after the last one. Please note: RunnableLambdas do not support `transform` by default! So if you need to use a RunnableLambdas be careful about where you place them in a RunnableSequence (if you need to use the .stream()/.astream() methods). If you need arbitrary logic and need streaming, you can subclass Runnable, and implement `transform` for whatever logic you need. Here is a simple example that uses simple functions to illustrate the use of RunnableSequence: .. code-block:: python from langchain_core.runnables import RunnableLambda def add_one(x: int) -> int: return x + 1 def mul_two(x: int) -> int: return x * 2 runnable_1 = RunnableLambda(add_one) runnable_2 = RunnableLambda(mul_two) sequence = runnable_1 | runnable_2 # Or equivalently: # sequence = RunnableSequence(first=runnable_1, last=runnable_2) sequence.invoke(1) await sequence.ainvoke(1) sequence.batch([1, 2, 3]) await sequence.abatch([1, 2, 3]) Here's an example that uses streams JSON output generated by an LLM: .. code-block:: python from langchain_core.output_parsers.json import SimpleJsonOutputParser from langchain_openai import ChatOpenAI prompt = PromptTemplate.from_template( 'In JSON format, give me a list of {topic} and their ' 'corresponding names in French, Spanish and in a ' 'Cat Language.' ) model = ChatOpenAI() chain = prompt | model | SimpleJsonOutputParser() async for chunk in chain.astream({'topic': 'colors'}): print('-') # noqa: T201 print(chunk, sep='', flush=True) # noqa: T201 Runnable[Input, Any]rrdefault_factoryrimiddlezRunnable[Any, Output]r~N)r`rrrr~rh RunnableLiker`r_Optional[Runnable[Any, Any]]"Optional[list[Runnable[Any, Any]]]rcNonecg}|s|| |g|pgz|gz}|D]T}t|tr||j2|t |Ut |dkr!dt |}t|t |dt|dd|d|dS)aCreate a new RunnableSequence. Args: steps: The steps to include in the sequence. name: The name of the Runnable. Defaults to None. first: The first Runnable in the sequence. Defaults to None. middle: The middle Runnables in the sequence. Defaults to None. last: The last Runnable in the sequence. Defaults to None. Raises: ValueError: If the sequence has less than 2 steps. Nrxz1RunnableSequence must have at least 2 steps, got rrrv)rrrr~r`) rrextendrhrrr|rZrN__init__r) ror`rrrr~rh steps_flatsteprrjs rrrzRunnableSequence.__init__ s(&(  ;*t/?FLb1TF:J < .9 sJ   T)  3K    rtcTg|]$}|dj"|%Sr)r startswith)rtuprs rrrz1RunnableSequence.config_specs..@ s3 U U USQ)=)=>S)T)T US U U Urtrc(h|]}|djSrrrs rrr+z0RunnableSequence.config_specs..G s$B$B$BDT!WZ$B$B$BrtcNg|]!}|jk|"Srr)rdrrs rrrz1RunnableSequence.config_specs..S sB&&& !+|A,,tw2G2GGGGGGrt)rrr`rr is_shared dependenciesc3 K|] \}}|V dSr r)rrrhs rrrz0RunnableSequence.config_specs..] s&&E&Eat&E&E&E&E&E&Ert)%langchain_core.beta.runnables.contextrrr/rhrrsetrrr;rr`rrrrrF) ro all_specs specs_by_pos next_deps deps_by_posposspecsrrrrs @@@rrrzRunnableSequence.config_specs+ s          &tz22    U U U UI U U U qMM  "ee +- & C CJC(K !$B$BE$B$B$BBII )) 4 4   C$w!!"788 )7#'?!Y $ $($4"&.&&&&&%0%5&&&  ,2 &4   " #$'&E&E9&E&E&EEEErtr7cddlm}|}|jD]}|}||}||jur|||jur|| |\}}|sd|d} t| |r| |||S)Get the graph representation of the Runnable. Args: config: The config to use. Defaults to None. Returns: The graph representation of the Runnable. Raises: ValueError: If a Runnable has no first or last node. rr6ry has no first node) langchain_core.runnables.graphr7rh last_noderrrtrim_first_noder~trim_last_noderrZr) rorr7rrcurrent_last_node step_graphstep_first_noderhrs rrrzRunnableSequence.get_graph_ s 988888J C CD % 1 1 //J4:%%**,,,49$$))+++!&j!9!9 OQ" &:$::: oo%  C0/BBB rtrdcdddt|jDS)Nz | c3K|]9\}}|dkrt|ntt|dV:dS)rz| N)reprrG)rrss rrrz,RunnableSequence.__repr__.. s]  1AvvDGGG#;DGGT#J#J      rt)joinr/rhrs rr__repr__zRunnableSequence.__repr__ s>{{  !$*--      rtrrrct|trBt|jg|j|j|j|j|jRd|jp|jiSt|jg|j|jt |Rd|jiSNr`rrrrrr~r`rrs rrrzRunnableSequence.__or__ s e- . . #       Y,%*  J [  I  u % %        rtrrct|trBt|jg|j|j|j|j|jRd|jp|jiStt ||jg|j|jRd|jiSrrrs rrrzRunnableSequence.__ror__ s e- . . #       Z,49  u % % J [  I        rtrr<rrr=c ddlm}|t||j}t |}|d||dp||dd} t|jD]\}}t|| d|dz}t|5} |dkr| j |j||fi|}n| |j||}dddn #1swxYwY ||t!d |S#t"$r} || d} ~ wwxYw) Nrconfig_with_contextrrr`r seq:step:rrr=)rrr-rhr/rrrsr1r/r3rr5rrrrrr) rorrrrrrrrrrs rrrzRunnableSequence.invoke s NMMMMM%$]6%:%:DJGG:6BB&55  J'':4==??::h-- 6   )$TZ00 H H4%k&;&;AF#AE ? F E FE F F. F))F.Frrrrrrc  ddlmddlm|sgSfdt |t |D}fd|D}fdt |||D} |ritjD]\}fdtt |D} |j fdt | |Dfd tt ||Dfd |idkr|ni} d t | |Dd |D}t t |krn| } g}tt |D]Xvr*| td 0| | dYnMtjD]8\}|j |fdt ||Dfd |idkr|ni}9d} t ||D]I\} } t!| t"r| p| } | | 4| | J|s| td|S| #t($rC|D]}||r!tdfd|DcYdSdwwxYw)NrrCallbackManagerc2g|]}|jSrrh)rrrros rrrz*RunnableSequence.batch.. s8    4: . .   rtc g|]W}|ddd|dd|ddXSrNFtagsrinheritable_callbackslocal_callbacksverboseinheritable_tags local_tagsinheritable_metadatalocal_metadata configurer)rrrs rrrz*RunnableSequence.batch.. sy      % %&,jj&=&= $!'F!3!3%+ZZ %;%;# &      rtc g|]Z\}}}|d||dp|dd[SNrrrrrcmrrros rrrz*RunnableSequence.batch..- sy   "E6   ZZ ++>t}}zz(D11      rtcg|]}|v| Srrrrfailed_inputs_maps rrrz*RunnableSequence.batch..A +&&&!CT:T:T:T:T:Trtc"g|] \}}|v | Srrrrinprs rrrz*RunnableSequence.batch..F 3 &3 (999 999rtc xg|]6\}\}}|v t||ddz7Srrrrrrrrrstepidxs rrrz*RunnableSequence.batch..K i !0.Y > &3)#y99srtc<g|]}t|t|Srrrrs rrrz*RunnableSequence.batch.._ 'VVVc:c9;U;UVcVVVrtr<c jg|]/\}}t||ddz0Srrrrrrs rrrz*RunnableSequence.batch..p \ !+F) &",,?R1q5?R?R2S2Srtrcg|]}Srrrs rrrz*RunnableSequence.batch.. ,?,?,?1Q,?,?,?rt)rr langchain_core.callbacks.managerrr0r|r0r/rhrangerupdatecopyrrr1rr rrr)rorrrrrrrrremaining_idxs inputs_copyrrr'rrrrrrrs` @@@@@@rrrzRunnableSequence.batch s NMMMMMDDDDDD I     $VS[[99        "        &)):FG%L%L   T " @ ;=!%.tz%:%:$$MGT&&&&#(W#6#6&&&N(TZ*-nf*E*E  4=Sw=W=W3X3X  +< &-\\66r!F&&,,*-nf*E*EWVVVVVF,--W==>%kkmm s7||,,::A--- d74Ea4H&I&IJJJJ kooa&8&89999 : )44  GAt'TZ /2,.H.H   +< &'!VV66  FF*48O$' f$=$= 2 2 Sc9--2&5&<O..s3333,,S1111  4O$;NF333! !!   " % %!!!$$$$  AN,?,?,?,?,?,?,?@@@@@@@@   s%.GJ66 L7K>7L=K>>Lc Kddlmddlm|sgSfdt |t |D}fd|D}t jfdt|||Dd{V} |ritj D]\}fdtt |D} |j fdt| |Dfd tt||Dfd |idkr|nid{V} d t| |Dd |D}t t |krn|} g}tt |D]Xvr*|t!d 0|| dYnStj D]>\}|j |fdt||Dfd |idkr|nid{V}?d} g} t||D]o\} }t%|t&r-| p|} | | |G| | |pt j| d{V|s| t!d|S| #t,$rIt jfd|Dd{V|r!t!dfd|DcYdSdwwxYw)Nrr)AsyncCallbackManagerc2g|]}|jSrr)rrrros rrrz+RunnableSequence.abatch.. s8    ! DJ / /   rtc g|]W}|ddd|dd|ddXSrr)rrrs rrrz+RunnableSequence.abatch.. sy     ! * *&,jj&=&= $!'F!3!3%+ZZ %;%;# +      rtc 3K|]\\}}}|d||dp|ddV]dSrrrs rrrz*RunnableSequence.abatch.. s&Bv !!J//B4==??!::h55 "rtcg|]}|v| Srrrs rrrz+RunnableSequence.abatch.. rrtc"g|] \}}|v | Srrrs rrrz+RunnableSequence.abatch.. rrtc xg|]6\}\}}|v t||ddz7Srrrs rrrz+RunnableSequence.abatch.. rrtrcDi|]\}}t|t||Srrrs rrrz+RunnableSequence.abatch.. rrtc<g|]}t|t|Srrr s rrrz+RunnableSequence.abatch.. r rtr<c jg|]/\}}t||ddz0Srrr s rrrz+RunnableSequence.abatch.. r rtrc3BK|]}|VdSr r)rrrs rrrz*RunnableSequence.abatch.. s1"O"OB2#4#4Q#7#7"O"O"O"O"O"Ortcg|]}Srrrs rrrz+RunnableSequence.abatch.. rrt)rrrrr0r|rIrr0r/rhrr<rrrrr1rr rrr)rorrrrrrrrrrrr;rr'rrrrrrs` @@@@@@rrr<zRunnableSequence.abatch sR ONNNNNIIIIII I     $VS[[99        "    ELN*-->)P)P E ? ? ? ? ? ? T " @ ;=!%.tz%:%:$$MGT&&&&#(W#6#6&&&N$/4;*-nf*E*E  4=Sw=W=W3X3X  $$+<$ &-\\66r!$$F&&,,*-nf*E*EWVVVVVF,--W==>%kkmm s7||,,::A--- d74Ea4H&I&IJJJJ kooa&8&89999 : )44  GAt#.4; /2,.H.H  $ $+< $&'!VV66 $ $      FF&48O+-E$' f$=$= @ @ Sc9--@&5&<OLL!;!;C!@!@AAAALL!9!9#!>!>????.%( ( ( ( ( ( ( (  4O$;NF333! !#   ."O"O"O"O,"O"O"OP P P P P P P P  AN,?,?,?,?,?,?,?@@@@@@@@   s%G"L M%=M M%M  M%rwrrPr*rMc +pKddlm}|jg|jz|jgz}|||j}t d|}t|D][\}} t|| d|dz}|dkr| j ||fi|}E| ||}\|Ed{VdS)NrrrMrrr) rrrrrr~rhrr/r3rr|) rorrrrrrhfinal_pipelinerrs rr _transformzRunnableSequence._transform s NMMMMM t{*di[8$$VTZ88 0%88"5)) H HIC!+"7"78MC!G8M8M"N"NFaxx!/!Q!Q&!Q!Q!%!G!G!!!!!!!!!!rtr}rOrPc Kddlm}|jg|jz|jgz}|||j}t d|}t|D][\}} t|| d|dz}|dkr| j ||fi|}E| ||}\|23d{V} | WV 6dS)NrrrPrrr) rrrrrr~rhrr/r3rr) rorrrrrrhr$rrrs rr _atransformzRunnableSequence._atransform. s' ONNNNN t{*di[8%%fdj99 5u=="5)) I IIC!%//0EC!G0E0EFFFaxx!0!R!R6!R!R!%!H!H*       &LLLLL+NNs0B=c +K|j||jt||pidp|jfi|Ed{VdSNr)r)rr%r3rr`rs rrr|zRunnableSequence.transformK s645  O 6$w--BB6BBBBBBBBBBBrtc K|j||jt||pidp|jfi|23d{V}|WV 6dSr))r"r'r3rr`rorrrrs rrrzRunnableSequence.atransformb s?4>    6.input_aiterx KKKKKKrtrcr}rrorrrr2rs ` rrrRzRunnableSequence.astreamq       +4?;;==&KKFKK       %KKKKKLKK.) rhrr`r_rrrrrr~rrcrrcr)rcrircrr-r.r r/r0r1rcrdr2r3r4rr<rrrrrcr=r5 rrwrrPrr*rrrcrM rr}rrOrr*rrrcrPr>r<r?r=)%rkrrDrErFr!rrr classmethodr%rrGrhrr rerrrrrrrrrrrrr<r%r'r|rOrrRrfrgs@rrrrg s<LLb -',uT'B'B'BFBBBB/, #.259-1 $ $ $ $ $ $ $ $ L 333X[3888X8 X[: $L $$$XX$ $$$XX$15 5 5 5 5X 515 6 6 6 6X 6 0F0F0FXX0FdX>   X    X 6   X 6?C")")")")X")H,0&)&)&)&)X&)PIM" #( """""X"BIMB" #( B"B"B"B"B"XB"H""""6:,0     X  ,0CCCCXC,0    X ,0    X     rtrc8eZdZUdZded< d9d:fd Zeed;d ZeeddZe d9d?fd Ze d9d?dZe ed@dZed9dAd!ZedBd"Ze d9dCd&Ze d9dDd(ZdEd.Ze d9dFd0Ze d9dGd1ZdHd5Ze d9dId7Ze d9dJd8ZxZS)Kra Runnable that runs a mapping of Runnables in parallel. Returns a mapping of their outputs. RunnableParallel is one of the two main composition primitives for the LCEL, alongside RunnableSequence. It invokes Runnables concurrently, providing the same input to each. A RunnableParallel can be instantiated directly or by using a dict literal within a sequence. Here is a simple example that uses functions to illustrate the use of RunnableParallel: .. code-block:: python from langchain_core.runnables import RunnableLambda def add_one(x: int) -> int: return x + 1 def mul_two(x: int) -> int: return x * 2 def mul_three(x: int) -> int: return x * 3 runnable_1 = RunnableLambda(add_one) runnable_2 = RunnableLambda(mul_two) runnable_3 = RunnableLambda(mul_three) sequence = runnable_1 | { # this dict is coerced to a RunnableParallel "mul_two": runnable_2, "mul_three": runnable_3, } # Or equivalently: # sequence = runnable_1 | RunnableParallel( # {"mul_two": runnable_2, "mul_three": runnable_3} # ) # Also equivalently: # sequence = runnable_1 | RunnableParallel( # mul_two=runnable_2, # mul_three=runnable_3, # ) sequence.invoke(1) await sequence.ainvoke(1) sequence.batch([1, 2, 3]) await sequence.abatch([1, 2, 3]) RunnableParallel makes it easy to run Runnables in parallel. In the below example, we simultaneously stream output from two different Runnables: .. code-block:: python from langchain_core.prompts import ChatPromptTemplate from langchain_core.runnables import RunnableParallel from langchain_openai import ChatOpenAI model = ChatOpenAI() joke_chain = ( ChatPromptTemplate.from_template("tell me a joke about {topic}") | model ) poem_chain = ( ChatPromptTemplate.from_template("write a 2-line poem about {topic}") | model ) runnable = RunnableParallel(joke=joke_chain, poem=poem_chain) # Display stream output = {key: "" for key, _ in runnable.output_schema()} for chunk in runnable.stream({"topic": "bear"}): for key in chunk: output[key] = output[key] + chunk[key].content print(output) # noqa: T201 z"Mapping[str, Runnable[Input, Any]]roNOptional[Mapping[str, Union[Runnable[Input, Any], Callable[[Input], Any], Mapping[str, Union[Runnable[Input, Any], Callable[[Input], Any]]]]]]rvUnion[Runnable[Input, Any], Callable[[Input], Any], Mapping[str, Union[Runnable[Input, Any], Callable[[Input], Any]]]]rcrc |i|ni}||td|DdS)zCreate a RunnableParallel. Args: steps__: The steps to include. Defaults to None. **kwargs: Additional steps to include. Nc4i|]\}}|t|Sr)r)rr[rs rrrz-RunnableParallel.__init__.. s'MMMFCS,Q//MMMrt)ro)rrNrr)rorormergedrjs rrrzRunnableParallel.__init__ sm0!( 3G f MMfllnnMMM      rtrcdSNTrrs rrrz#RunnableParallel.is_lc_serializable trtrc gdSrrrs rrrz!RunnableParallel.get_lc_namespace rrtTrrarbr_r`rdc|p6|jp/dd|jd}t ||S)zGet the name of the Runnable. Args: suffix: The suffix to use. Defaults to None. name: The name to use. Defaults to None. Returns: The name of the Runnable. zRunnableParallel<,>ra)r`rrorrNrsrorbr`rjs rrrszRunnableParallel.get_name sYXtyX$XARARATAT8U8U$X$X$XwwT222rtrch|jD]}|jr |jcStSr)rorrr)rors rrrzRunnableParallel.InputTypesEL'')) & &D~ &~%%% & rtrrrc:tfd|jDrGt|dfd|jDSt S)rc3K|]C}|dddkVDdS)rXobjectN)rrr)rrrs rrrz4RunnableParallel.get_input_schema..$sk     v & & 8 8 : : > >vx P P       rtr<ci|]I}|jD]\}}|dk ||j|jfJS)__root__)rrYrrr)rrrprqrs rrrz5RunnableParallel.get_input_schema..,sl### $ 5 5f = = J P P R R##1J ai0'rtr)allrorrNrsrNrrorrjs `rrrz!RunnableParallel.get_input_schemas     \((**       # g&&#### $ 3 3 5 5### ww''///rtcd|jD}t|d|S)rc(i|]\}}||jdfS).)rrzs rrrz6RunnableParallel.get_output_schema..Bs%JJJTQ!alC(JJJrtr=r)rorrNrs)rorrVs rrrz"RunnableParallel.get_output_schema6sEKJT\5G5G5I5IJJJt}}X66&QQQQrtrcbtd|jDS)rc3.K|]}|jD]}|VdSr r)rrrs rrrz0RunnableParallel.config_specs..MsJ' ' t?P' ' 7;D' ' ' ' ' ' ' rt)rFrorrs rrrzRunnableParallel.config_specsEs@'' ' !\0022' ' '    rtr7cddlm}|}|||}|||}|jD]}|}|| |s| ||W| |\}} |sd|d} t| | sd|d} t| | ||| | ||S)rrr6ryr has no last node) rr7rrrrorrrrrrrZ) rorr7rrrrrrstep_last_noders rrrzRunnableParallel.get_graphQs\ 988888^^D$9$9&$A$ABB nnT%;%;F%C%CDD L'')) < d>>>C$S//)%*=d===C$S//)z?;;;~{;;;; rtc~dd|jD}d|zdzS)Nz, c3lK|]/\}}|dtt|d|zdzV0dS)z: z N)rGrrzs rrrz,RunnableParallel.__repr__..xsa$ $ 1 H H,T!WWdQhoFF H H$ $ $ $ $ $ rtz{ z })rror)ro map_for_reprs rrrzRunnableParallel.__repr__vsQ||$ $  **,,$ $ $   %--rtrr<rc  ddlm}t|ddddddd}|ddp|d d  d fd t|j }t5  fd| D}dt||D}dddn #1swxYwY ||S#t$r} | d} ~ wwxYw)NrrrFrrrrrrrrrr<rr*r[rdrcrct|d|}t|5}||j||cdddS#1swxYwYdS)Nmap:key:r)r3rr5rrrrrr[rrrs rr _invoke_stepz-RunnableParallel.invoke.._invoke_steps(%//0@30@0@AAL $L11 W{{K                   sA!!A%(A%c Hg|]\}}||Srr))rr[rrerrrs rrrz+RunnableParallel.invoke..sA!TOOL$vsKKrtc>i|]\}}||Sr)r2)rr[r6s rrrz+RunnableParallel.invoke..s&VVV;3#v}}VVVrt rrrr<rr*r[rdrcr)rrr-rrrrsr1rror1rr0rrr) rorrrrrrhr4rrrerrs `` @@@rrrzRunnableParallel.invoke~s" EDDDDDv&&*44"(**["9"9 #ZZ//!'J!7!75  '55  J'':4==??::h-- 6          &&E(00 WH%*[[]]WV#eWBUBUVVV  W W W W W W W W W W W W W W W  $ $V , , ,M      & &q ) ) )  s< #E.>D8, E8D<<E?D<E E?$E::E?rc l Ktt}|ddp|ddd{V d fd t |j}tj fd| Dd{V}t t||} |d{V|S#t$r!} |d{Vd}~wwxYw)Nrrrrrrr<rr*r[rdrcrcKt|d|}t|5}t||||dd{VcdddS#1swxYwYdS)NrcrTr)r3rr5r@rrds rr _ainvoke_stepz/RunnableParallel.ainvoke.._ainvoke_steps(%//0@30@0@AAL$L11 W.LL 55wD                  s,A33A7:A7c3:K|]\}}||VdSr r)rr[rrkrrs rrrz+RunnableParallel.ainvoke..sU  "T"M       rtrh)r-r.rrrsr1rrorIrrr0rrr) rorrrrrhresultsrrrkrs `` @@rrrzRunnableParallel.ainvokesv&&@HH,;;  J'':4==??::h-- <               &&E#N      &+[[]]          G#eW--..F **622 2 2 2 2 2 2 2M    ,,Q// / / / / / / /  sA%D D3D..D3rwrrPr*Iterator[AddableDict]c# Kt|j}tt|t |t jt5 fd|D} fd|D}|rt|t\}}|D]r} | | \} } t| | i} | V| | f| t| <c#t $rYowxYw|ddddS#1swxYwYdS)Nlockc g|]T\}}||td|fUSrcr)r|r1r3rrr`rr input_copiesrs rrrz/RunnableParallel._transform..s   D$NN$((**$"k.C.CDUtDUDU.V.V   rtcRi|]#\}}t|||f$Sr)r*r )r step_name generatorrs rrrz/RunnableParallel._transform.. sB(Iyi009i2Hrtr,)rrorrMr| threadingLockr1rrr r1r8r2r*r r)rorrrrhnamed_generatorsr4completed_futuresrhr6rwrxrrrus `` @@rrr%zRunnableParallel._transformsT\""GE3u::IND;Iterator[dict[str, Any]]c+@K|j||j|fi|Ed{VdSr )rr%rs rrr|zRunnableParallel.transforms]645 4?F  .4           rtc+^K|t|g|Ed{VdSr r+rs rrrOzRunnableParallel.stream*s<>>$w--88888888888rtr}rOAsyncIterator[AddableDict]cnKt|j}tt|t |t jfd|D}d dfd|D}|rt j|t j d{V\}}|D]w} | | \} } t| | i} | WVt j | } | | f|| <h#t$rYtwxYw|dSdS) Nrpc g|]T\}}||td|fUSrs)rr1r3rrts rrrz0RunnableParallel._atransform..?s    d $$&& +*?*?@Q4@Q@Q*R*R     rtrxrrcOptional[Output]c0Kt|d{VSr )rL)rxs rrget_next_chunkz4RunnableParallel._atransform..get_next_chunkMs&!),,,,,,,, ,rtcVi|]%\}}tj|||f&Sr)rIr)rrwrxrs rrrz0RunnableParallel._atransform..QsI   $ 9  y 9 9 : :Y >)3L3LMMH'0)& 4#V  /5         %KKKKK   s%c pKdfd }|||23d{V}|WV 6dS)Nrcr}cKWVdSr rr1srrr2z-RunnableParallel.astream..input_aiteryr3rtr4r5r6s ` rrrRzRunnableParallel.astreamrs|       ??;;==&AA       %KKKKKBAAs5r )rorArrBrcrr:r9r,rcrr/r0r1r;)rr<rrrrrcr)rr<rrrrrcr)rrwrrPrr*rcrn)rrwrrrrrcr})rr<rrrrrcr})rr}rrOrr*rcr)rr}rrrrrcr)rr<rrrrrcr)rkrrDrErFrr?r%rrr rersrGrrrrrrrrr%r|rOr'rrRrfrgs@rrrr s1NN`0///        < X[ 333X[3: $L&* 3EI 3 3 3 3 3 3 3X 3 XX15000000X0:15 R R R RX R    XX """"X"H...X.?C8888X8t,04444X4l----^,0    X ,09999X91111f,0    X ,0    X     rtrceZdZdZ d)ddd*d Zeed+dZe d)d,dZeed+dZ e d)d,dZ ed-dZ ed.dZ e d)d/dZ e d)d0d!Ze d)d1d#Ze d)d2d&Ze d)d3d'Ze d)d1d(ZdS)4RunnableGeneratoru Runnable that runs a generator function. RunnableGenerators can be instantiated directly or by using a generator within a sequence. RunnableGenerators can be used to implement custom behavior, such as custom output parsers, while preserving streaming capabilities. Given a generator function with a signature Iterator[A] -> Iterator[B], wrapping it in a RunnableGenerator allows it to emit output chunks as soon as they are streamed in from the previous step. Note that if a generator function has a signature A -> Iterator[B], such that it requires its input from the previous step to be completed before emitting chunks (e.g., most LLMs need the entire prompt available to start generating), it can instead be wrapped in a RunnableLambda. Here is an example to show the basic mechanics of a RunnableGenerator: .. code-block:: python from typing import Any, AsyncIterator, Iterator from langchain_core.runnables import RunnableGenerator def gen(input: Iterator[Any]) -> Iterator[str]: for token in ["Have", " a", " nice", " day"]: yield token runnable = RunnableGenerator(gen) runnable.invoke(None) # "Have a nice day" list(runnable.stream(None)) # ["Have", " a", " nice", " day"] runnable.batch([None, None]) # ["Have a nice day", "Have a nice day"] # Async version: async def agen(input: AsyncIterator[Any]) -> AsyncIterator[str]: for token in ["Have", " a", " nice", " day"]: yield token runnable = RunnableGenerator(agen) await runnable.ainvoke(None) # "Have a nice day" [p async for p in runnable.astream(None)] # ["Have", " a", " nice", " day"] RunnableGenerator makes it easy to implement custom behavior within a streaming context. Below we show an example: .. code-block:: python from langchain_core.prompts import ChatPromptTemplate from langchain_core.runnables import RunnableGenerator, RunnableLambda from langchain_openai import ChatOpenAI from langchain_core.output_parsers import StrOutputParser model = ChatOpenAI() chant_chain = ( ChatPromptTemplate.from_template("Give me a 3 word chant about {topic}") | model | StrOutputParser() ) def character_generator(input: Iterator[str]) -> Iterator[str]: for token in input: if "," in token or "." in token: yield "👏" + token else: yield token runnable = chant_chain | character_generator assert type(runnable.last) is RunnableGenerator "".join(runnable.stream({"topic": "waste"})) # Reduce👏, Reuse👏, Recycle👏. # Note that RunnableLambda can be used to delay streaming of one step in a # sequence until the previous step is finished: def reverse_generator(input: str) -> Iterator[str]: # Yield characters of input in reverse order. for character in input[::-1]: yield character runnable = chant_chain | RunnableLambda(reverse_generator) "".join(runnable.stream({"topic": "waste"})) # ".elcycer ,esuer ,ecudeR" Nrar|mUnion[Callable[[Iterator[Input]], Iterator[Output]], Callable[[AsyncIterator[Input]], AsyncIterator[Output]]]rAOptional[Callable[[AsyncIterator[Input]], AsyncIterator[Output]]]r`r_rcrc| ||_|}t|r ||_|}n?tj|r ||_|}n!dt |}t | |p|j|_dS#t$r d|_YdSwxYw)aBInitialize a RunnableGenerator. Args: transform: The transform function. atransform: The async transform function. Defaults to None. name: The name of the Runnable. Defaults to None. Raises: TypeError: If the transform is not a generator function. NzTExpected a generator function type for `transform`.Instead got an unsupported type: r) r'rIrisgeneratorfunctionr%rXr~rkr`AttributeError)ror|rr` func_for_namers rrrzRunnableGenerator.__init__s,  !)D &0M i ( ( !(D %MM  ( 3 3 !'DO%MMF48OOFF C..  ,6 6DIII , , ,+DIIII ,s%A55B  B rcpt|ddp|j} tj|j}t t |d}|r<|jtj j kr"t|jdtfdSn#t$rYnwxYwtSNr%__args__r) getattrr'r signature parametersr r,rr ParameteremptyrrZrorparams first_params rrrzRunnableGenerator.InputTypest\400DD4D &t,,7FtFMMOO44d;;K N{59J9PPP{5zC6JJ1MM    D  sBB!! B.-B.rrrc,|j}t|ddp|j}t|dd}tj|r,t |t st|tr|St| d||S)Nr%rr<r) rrr'rrrrrrrNrsrorrrmodules rrrz"RunnableGenerator.get_input_schemasN t\400DD4D|T22 OI & & y,77 9i00    MM' " "     rtct|ddp|j} tj|}|jtjjkr"t|jdtfdntS#t$r tcYSwxYwr) rr'rrreturn_annotation SignaturerrrZrorsigs rrrzRunnableGenerator.OutputType/st\400DD4D #D))C(G,=,CCC-zC6BB1EE     JJJ sAA11BBc,|j}t|ddp|j}t|dd}tj|r,t |t st|tr|St| d||S)Nr%rr=r) rrr'rrrrrrrNrsrs rrrz#RunnableGenerator.get_output_schema=sO t\400DD4D|T22 OI & & y,77 9i00    MM( # #     rtrrRrct|trbt|dr t|dr|j|jkSt|dr t|dr|j|jkSdSdS)Nr%r'F)rrrir%r'rs rr__eq__zRunnableGenerator.__eq__Xs e. / / t\** ;wul/K/K ;%*:::t]++ =}0M0M ='5+<<<5urtrdcd|jdS)NzRunnableGenerator()rars rrrzRunnableGenerator.__repr__bs0DI0000rtrrwrrMc t|ds!t|d}t||j||j|fi|S)Nr%z only supports async methods.)rirrsrr%rorrrrs rrr|zRunnableGenerator.transformfsit\** +$ZZ>>>C%c** *1t1  O       rtr<c <|jt|g|fi|Sr r+rs rrrOzRunnableGenerator.streamw(t~dE7mmV>>v>>>rtr=c \d}|j||fi|D] }||n||z} td|SNr=)rOrrorrrr{rs rrrzRunnableGenerator.invokesS#'!dk%::6:: @ @F#mFFEEHe$$$rtr}rPc t|ds!t|d}t||j||j|fi|S)Nr'z only supports sync methods.)rirrsr"r'rs rrrzRunnableGenerator.atransformsft]++ +$ZZ===C%c** *2t2 4#V  /5   rtc >dfd }|j||fi|S)Nrcr}cKWVdSr rr1srrr2z.RunnableGenerator.astream..input_aiterr3rtr4r5)rorrrr2s ` rrrRzRunnableGenerator.astreamsE      t{{}}f?????rtclKd}|j||fi|23d{V}||n||z}6td|Sr)rRrrs rrrzRunnableGenerator.ainvokes{#'(DLAA&AA @ @ @ @ @ @ @&#mFFEEBHe$$$s%r )r|rrrr`r_rcrrr/rrRrcrr;rrwrrrrrcrM)rr<rrrrrcrMr4rr}rrrrrcrP)rr<rrrrrcrP)rkrrDrErrGr%rrrrrrr|rOrrrRrrrtrrrrs0SSz *,#*,*,*,*,*,*,X    XX 15    X 6    XX 15    X 4X111X1,0    X ,0????X??C%%%%X%,0     X  ,0 @ @ @ @X @?C%%%%X%%%rtrceZdZdZ d8d9d Zeed:d Ze d;d<fd Zeed:dZ e d;ddZed;d?fd Zed@dZdAd ZdBd(ZdCd*Ze d;dDd,Ze d;dDd-ZdEd0Ze d;dFd1Ze d;dGd2ZdHd5Ze d;dId6Ze d;dJd7ZxZS)KRunnableLambdaa0RunnableLambda converts a python callable into a Runnable. Wrapping a callable in a RunnableLambda makes the callable usable within either a sync or async context. RunnableLambda can be composed as any other Runnable and provides seamless integration with LangChain tracing. ``RunnableLambda`` is best suited for code that does not need to support streaming. If you need to support streaming (i.e., be able to operate on chunks of inputs and yield chunks of outputs), use ``RunnableGenerator`` instead. Note that if a ``RunnableLambda`` returns an instance of ``Runnable``, that instance is invoked (or streamed) during execution. Examples: .. code-block:: python # This is a RunnableLambda from langchain_core.runnables import RunnableLambda def add_one(x: int) -> int: return x + 1 runnable = RunnableLambda(add_one) runnable.invoke(1) # returns 2 runnable.batch([1, 2, 3]) # returns [2, 3, 4] # Async is supported by default by delegating to the sync implementation await runnable.ainvoke(1) # returns 2 await runnable.abatch([1, 2, 3]) # returns [2, 3, 4] # Alternatively, can provide both synd and sync implementations async def add_one_async(x: int) -> int: return x + 1 runnable = RunnableLambda(add_one, afunc=add_one_async) runnable.invoke(1) # Uses add_one await runnable.ainvoke(1) # Uses add_one_async Nr Union[Union[Callable[[Input], Output], Callable[[Input], Iterator[Output]], Callable[[Input, RunnableConfig], Output], Callable[[Input, CallbackManagerForChainRun], Output], Callable[[Input, CallbackManagerForChainRun, RunnableConfig], Output]], Union[Callable[[Input], Awaitable[Output]], Callable[[Input], AsyncIterator[Output]], Callable[[Input, RunnableConfig], Awaitable[Output]], Callable[[Input, AsyncCallbackManagerForChainRun], Awaitable[Output]], Callable[[Input, AsyncCallbackManagerForChainRun, RunnableConfig], Awaitable[Output]]]]afunc3Optional[Union[Callable[[Input], Awaitable[Output]], Callable[[Input], AsyncIterator[Output]], Callable[[Input, RunnableConfig], Awaitable[Output]], Callable[[Input, AsyncCallbackManagerForChainRun], Awaitable[Output]], Callable[[Input, AsyncCallbackManagerForChainRun, RunnableConfig], Awaitable[Output]]]]r`r_rcrc| ||_|}t|st|r|d}t|||_|}nHt |rt d||_|}n!dt|}t| |||_n|j dkr |j |_n#t$rYnwxYwd|_ dS)aECreate a RunnableLambda from a callable, and async callable or both. Accepts both sync and async variants to allow providing efficient implementations for sync and async execution. Args: func: Either sync or async callable afunc: An async callable that takes an input and returns an output. Defaults to None. name: The name of the Runnable. Defaults to None. Raises: TypeError: If the func is not a callable type. TypeError: If both func and afunc are provided. NzFunc was provided as a coroutine function, but afunc was also provided. If providing both, func should be a regular function to avoid ambiguity.Callable[[Input], Output]zEExpected a callable type for `func`.Instead got an unsupported type: z) rrHrIr~callablerrrXr`rkr_repr)rorrr`rrs rrrzRunnableLambda.__init__sd  DJ&+M T " " !&8&>&> ! 3  nn$DJ MM d^^ !8$??DI MMA48JJAA C..    ':55)2     D %) s!B22 B?>B?rc:t|ddp|j} tj|j}t t |d}|r!|jtj j kr|jSn#t$rYnwxYwtS)z'The type of the input to this Runnable.rN) rrrrrr r,rrrrrZrrs rrrzRunnableLambda.InputType0stVT**8dj &t,,7FtFMMOO44d;;K .{59J9PPP"--    D  sA*B BBrrrcFt|ddp|j}t|trt |ddddd}td|Dr0d|D}t| d | St|d d}t| d tt| S|j tkr!t|St|x}rDt| d t |td f St|S)zThe pydantic schema for the input to this Runnable. Args: config: The config to use. Defaults to None. Returns: The input schema for this Runnable. rNzoperator.itemgetter(rrvz, c3lK|]/}|ddko|ddkot|dkV0dS)r'rvrxN)r|rris rrrz2RunnableLambda.get_input_schema..PsWIMQ3D48s?Ds4yy1}rtc2i|]}|ddtdfS)rrv.)rrs rrrz3RunnableLambda.get_input_schema..Ss&CCCT$qt*sCjCCCrtr<rrr.)rrrrrdreplacesplitrUrNrsrrrrNrrCrfromkeys)rorrrrVr dict_keysrjs rrrzRunnableLambda.get_input_schema>stVT**8dj dJ ' ' II%%&td|jDS)Nc3.K|]}|jD]}|VdSr r)rdeprs rrrz.RunnableLambda.config_specs..sJ' ' #2B' ' *.D' ' ' ' ' ' ' rt)rFrrs rrrzRunnableLambda.config_specss4'' '  I' ' '    rtRunnableConfig | Noner7c|jx}r+t}|||}|||}|D]}|}|||s|||W| |\}} |sd|d} t| | sd|d} t| ||||| |n!t|}|S)Nryrr\) rr7rrrrrrrrrZrN) rorrrrrr dep_graphdep_first_node dep_last_noderrjs rrrzRunnableLambda.get_graphsd9 4 .GGE(=(=f(E(EFFJ..)?)?)G)GHHK ? ?MMOO ))+++((*** ?NN:{;;;;49LL4K4K1NM).A#AAA(oo-(.@#@@@(oo-NN:~>>>NN=+>>>> ?"GG%%f--E rtrrRrct|trbt|dr t|dr|j|jkSt|dr t|dr|j|jkSdSdS)NrrF)rrrirrrs rrrzRunnableLambda.__eq__s e^ , , tV$$ /)?)? /yEJ..tW%% 1'%*A*A 1zU[005urtrdc|jt|drMt|jtr3dt |jt ddd|_ngt|dr dt|jpdd|_n7t|dr dt|jpdd|_nd |_|jS) z)A string representation of this Runnable.NrzRunnableLambda(z operator.rz...rzRunnableLambda(afunc=zRunnableLambda(...)) rrirrrrdr|rErrs rrrzRunnableLambda.__repr__s : tV$$ 3DIz)J)J 3Ts49~~c+>N>N>P>P/QTTT v&& 3W/@/K/K/TuWWW w'' 3U,=dj,I,I,RUUUU 3 zrtrr<rrPr*rr=c tj|jrFd}tt d|j|||fi|D]}||} ||z}#t $r|}YwxYwnt|j|||fi|}t |tra|d}|dkrd|d|d}t|| |t|| |dz }t d |S) N#Callable[[Input], Iterator[Output]]recursion_limitr&Recursion limit reached when invoking with input .rrrr=) rrrr,rr~rr^RecursionErrorrr3r) rorrrrrrrrs rr_invokezRunnableLambda._invokesx  &ty 1 1 '+F5:DIFF    ' '>"FF'!'%$'''!&' '2 5&+9?F fh ' ' $%67O!##WTWWuWWW%S)))]])3355$3a$7FHf%%%sA  AArOc ~ Ktdrj}nDtjjrdfd ndfd t d fd }|}t |rd}ttdttd|||fi|4d{V }td|23d{V} || } || z}#t$r| }Y!wxYw6 dddd{Vn#1d{VswxYwYn$ttd|||fi|d{V}t|trgd} | dkrdd|d} t| ||t|| dz d{V}td |S)Nrrr<rrOrr*rrrcr=cd}ttdj|||fi|D]}||} ||z}#t$r|}YwxYwtd|S)Nrr=)r,rrget_syncr~)rrrrrrros rrrz%RunnableLambda._ainvoke..func(s 04F!=BDINN#,,.. "" ! "" / /">%*FF/)/%#,///)./&111sA AAcRtj|||fi|Sr r,rrrrrrros rrrz%RunnableLambda._ainvoke..funcAs; 8 5&+2F2F2H2HLRrtrwc6Ktg|Ri|d{VSr r4rwrrrs rrfz"RunnableLambda._ainvoke..fK9,VTKDKKKFKKKKKKKKKrtzAsyncGenerator[Any, Any]rrPrrrrrrr rr<rrOrr*rrrcr=rwrrrrcr)rirrrrrrIrJrr+r~rr^rrr3r) rorrrrrrrrOrrrrs ` ` @rr_ainvokezRunnableLambda._ainvokesu 4 ! !, JEE*4955# 222222224[[ L L L L L L[ LE e $ $ '+F.1Z//#  !      + + + + + + + +#'+$$ + + + + + + +%~!&+%+e^FF(+++%*FFF+$$ + + + + + + + + + + + + + + + + + + + + + + + + + + +09Z'' GMF fh ' ' $%67O!##WTWWuWWW%S)))!>>)3355$3a$7FHf%%%sB3C=C) C=CC= C&#C=%C&&C== D Drc t|dr"|j|j|t|fi|Sd}t |)aaInvoke this Runnable synchronously. Args: input: The input to this Runnable. config: The config to use. Defaults to None. kwargs: Additional keyword arguments. Returns: The output of this Runnable. Raises: TypeError: If the Runnable is a coroutine function. rzGCannot invoke a coroutine function synchronously.Use `ainvoke` instead.)rirrr-r~rs rrrzRunnableLambda.invokesc( 4  )4) f%%   XnnrtcVK|j|j|t|fi|d{VS)aInvoke this Runnable asynchronously. Args: input: The input to this Runnable. config: The config to use. Defaults to None. kwargs: Additional keyword arguments. Returns: The output of this Runnable. N)rrr-rs rrrzRunnableLambda.ainvokes_"-T, M  & ! !            rtrwrMc +Kd}|D]!}|s|}d} ||z}#t$r|}YwxYwtj|jr"FF'!'%$'''!&' '2 5&+9?F fh ' ' )$%67O!##WTWWuWWW%S))))3355$3a$7     ,TY77 )x(( ( ( ( ( ( ) )s &&%A++ A:9A:c+Kt|dr*|j||jt|fi|Ed{VdSd}t |)NrzGCannot stream a coroutine function synchronously.Use `astream` instead.)rirr%r-r~rs rrr|zRunnableLambda.transforms 4 !9t9f%%          ) C.. rtc <|jt|g|fi|Sr r+rs rrrOzRunnableLambda.stream rrtr}rPc Kd}|23d{V}|s|}d} ||z}#t$r|}Y#wxYw6tdrj}nNtjjrd} t| dfd t dfd } | }t|rZd} tdttd|||fi|23d{V} | WV| | }  | | z} #t$r| } Y&wxYw6n$ttd|||fi|d{V} t| trqd} | dkrdd|d} t| | |t|| dz 23d{V} | WV 6dSt|std| WVdSdS)NFTrzMCannot stream from a generator function asynchronously.Use .stream() instead.rr<rrOrr*rrrcr=cRtj|||fi|Sr rrs rrrz(RunnableLambda._atransform..func3s; 4Iufk.B.B.D.DHNrtrwc6Ktg|Ri|d{VSr rrs rrrz%RunnableLambda._atransform..f=rrtrPrrrrrrrrrr)r~rirrrrrrIrr+rr^rrRr3r)rorrrrryrzr{rrrrrrrs` ` @rrr'zRunnableLambda._atransformsl ! # # # # # # #& ! # $ #!FNEE ###"EEE#" 4 ! ! JEE*4955 %- nn$      4[[ L L L L L L[ LE e $ $ '+F#'-U++      ' ' ' ' ' ' 'e >"FF'!'%$'''!&'!  &9Z''   F fh ' ' )$%67O!##WTWWuWWW%S)))%~~)3355$3a$7         e    $E** )x(( ( ( ( ( ( ( ) )s.1 ..C?'C-- C<;C<F(c jK|j||jt|fi|23d{V}|WV 6dSr )r"r'r-)rorrrrs rrrzRunnableLambda.atransformus@D?    & ! !            & LLLLL    s2c bKdfd }|j||fi|23d{V}|WV 6dS)Nrcr}cKWVdSr rr1srrr2z+RunnableLambda.astream..input_aiterr3rtr4r5r6s ` rrrRzRunnableLambda.astreamr7r8rC)rrrrr`r_rcrrr r/)rcrr0)rrrcr7rr;) rr<rrPrr*rrrcr=rr<r=r>r<r>r?r=)rkrrDrErrGr%rrrrrcached_propertyrrrrrrrrrr%r|rOr'rrRrfrgs@rrrrs ++Z "CR)R)R)R)R)h    XX 15*0*0*0*0*0*0X*0X XX*15    X 4,    XX X4X    +&+&+&+&Zb&b&b&b&H,0X:,0    X .<)<)<)<)|,0!!!!X!(,0????X?a)a)a)a)F,0    X ,0    X     rtrceZdZUdZded<edZeed*dZ e d+d,d Z eed-dZ e d+d,dZ eed.dZ ed+d/dZeed0dZeed1dZd2d Ze d+d3d"Zd4d$Ze d+d3d%Ze d+d5d)Zd S)6RunnableEachBasezRunnable that calls another Runnable for each element of the input sequence. Use only if creating a new RunnableEach subclass with different __init__ args. See documentation for RunnableEach for more details. rrTrrcrc0t|jjSr )rrrrs rrrzRunnableEachBase.InputTypesDJ())rtNrrrct|dt|j|df|jjS)Nr<r)rNrsrrrrjrrs rrrz!RunnableEachBase.get_input_schemasT MM' " "TZ008891    rttype[list[Output]]c0t|jjSr )rrrrs rrrzRunnableEachBase.OutputTypesDJ)**rtc|j|}t|dt||jjS)Nr=r)rrrNrsrrjr)rorrs rrrz"RunnableEachBase.get_output_schemasP--f55 MM( # #f1    rtrc|jjSr rrrs rrrzRunnableEachBase.config_specsz&&rtr7c6|j|Sr )rrrs rrrzRunnableEachBase.get_graphsz##F+++rtrcdSrHrrs rrrz#RunnableEachBase.is_lc_serializablerIrtrc gdSrrrs rrrz!RunnableEachBase.get_lc_namespacerrtrrrrPr*rrc Lfd|D}|jj||fi|S)NcVg|]%}t&Srrrrhrrs rrrz,RunnableEachBase._invoke..?   HIL;+@+@+B+B C C C   rt)rrrorrrrrs `` rrrzRunnableEachBase._invokesR     MS    tz::6:::rtrc ,|j|j||fi|Sr )rrrs rrrzRunnableEachBase.invokes%&t%dlE6LLVLLLrtrOc\Kfd|D}|jj||fi|d{VS)NcVg|]%}t&Srrrs rrrz-RunnableEachBase._ainvoke..rrt)rr<rs `` rrrzRunnableEachBase._ainvokesh     MS   'TZ&vwAA&AAAAAAAAArtc<K|j|j||fi|d{VSr )rrrs rrrzRunnableEachBase.ainvokes;-T,T]E6TTVTTTTTTTTTrtr<rrmc NKtdD]}d}t|dS)Nrz1RunnableEach does not support astream_events yet.)rrs)rorrrrhrs rrrvzRunnableEachBase.astream_eventss:q  AEC%c** *  rtrr r/)rcr r0r1r:r9) rrrrPrr*rrrcr)rrrrrrrcr) rrrrOrr*rrrcrrr<rrrrrcrm)rkrrDrErFr rerGr%rrrrrrr?rrrrrrrvrrtrrr r s>#""": $L ***XX*15    X & +++XX+15    X " '''XX',,,,X, X[ 333X[3 ; ; ; ;EIMMMMXM B B B BEIUUUUXU ,0    X   rtr ceZdZdZe ddddfd Zedd Ze dddZeddddddZddddddZ xZ S)ra_Runnable that calls another Runnable for each element of the input sequence. It allows you to call multiple inputs with the bounded Runnable. RunnableEach makes it easy to run multiple inputs for the Runnable. In the below example, we associate and run three inputs with a Runnable: .. code-block:: python from langchain_core.runnables.base import RunnableEach from langchain_openai import ChatOpenAI from langchain_core.prompts import ChatPromptTemplate from langchain_core.output_parsers import StrOutputParser prompt = ChatPromptTemplate.from_template("Tell me a short joke about {topic}") model = ChatOpenAI() output_parser = StrOutputParser() runnable = prompt | model | output_parser runnable_each = RunnableEach(bound=runnable) output = runnable_each.invoke([{'topic':'Computer Science'}, {'topic':'Art'}, {'topic':'Biology'}]) print(output) # noqa: T201 Nrarbr_r`rcrdc|p#|jpd|jd}t||S)Nz RunnableEach*++!&8,    rtrcXt|j|||S)aBind async lifecycle listeners to a Runnable, returning a new Runnable. Args: on_start: Called asynchronously before the Runnable starts running, with the Run object. Defaults to None. on_end: Called asynchronously after the Runnable finishes running, with the Run object. Defaults to None. on_error: Called asynchronously if the Runnable throws an error, with the Run object. Defaults to None. Returns: A new Runnable with the listeners bound. The Run object contains information about the run, including its id, type, input, output, error, start_time, end_time, and any tags or metadata added to the run. rr)rrrr's rrrzRunnableEach.with_alistenerses<0*,,!&8-    rtr r,)rrrcr#)rrrrrcr#)rrrrrrrcr#)rrrrrrrcr#) rkrrDrEr%rsrrrrrfrgs@rrrrs4&*3EI3333333X3 ===X=15LLLLXL    " " " " " X" N-1*.,0           rtrceZdZUdZded< eeZded< eeZ ded< ee Z d ed < d Z d ed < d Z d ed< edZd d d d d ddYfdZe dZd dd[d!Zeed\d#Zeed]d%Ze dZd^fd' Ze dZd^fd( Zeed_d*ZedZd`d,Zeedad.Zeedbd0Zdcd2Ze dZddd6Ze dZddd7Ze dZd8d9ded?Z e dZd8d9ded@Z!e" dZd8d9dfdEZ#e" dZdgdHZ#e dZd8d9dhdIZ#e" dZd8d9didKZ$e" dZdjdMZ$e dZd8d9dkdNZ$e dZdldPZ%e dZdmdRZ&e dZdndTZ'e dZdodVZ(e dZdpdXZ)xZ*S)qRunnableBindingBasezRunnable that delegates calls to another Runnable with a set of kwargs. Use only if creating a new RunnableBinding subclass with different __init__ args. See documentation for RunnableBinding for more details. rrrzMapping[str, Any]rr*rz0list[Callable[[RunnableConfig], RunnableConfig]]rNrrrTr)rrrrrOptional[Mapping[str, Any]]r:Optional[list[Callable[[RunnableConfig], RunnableConfig]]]'Optional[Union[type[Input], BaseModel]](Optional[Union[type[Output], BaseModel]] other_kwargsrrcrc ftjd||pi|pi|pg||d||pi|_dS)a>Create a RunnableBinding from a Runnable and kwargs. Args: bound: The underlying Runnable that this Runnable delegates calls to. kwargs: optional kwargs to pass to the underlying Runnable, when running the underlying Runnable (e.g., via `invoke`, `batch`, `transform`, or `stream` or async variants) Defaults to None. config: optional config to bind to the underlying Runnable. Defaults to None. config_factories: optional list of config factories to apply to the config before binding to the underlying Runnable. Defaults to None. custom_input_type: Specify to override the input type of the underlying Runnable with a custom type. Defaults to None. custom_output_type: Specify to override the output type of the underlying Runnable with a custom type. Defaults to None. **other_kwargs: Unpacked into the base class. rrrrrrNr)rNrr) rorrrrrrr/rjs rrrzRunnableBindingBase.__init__se@  .s+&P&PQqqyy&P&P&P&P&P&Prt)r2rr)rorrs @rrr9z"RunnableBindingBase._merge_configssHt{5W555VQ&P&P&P&P$:O&P&P&PQQQQrtrr<r=c b|jj|||fii|j|Sr )rrr9rrs rrrzRunnableBindingBase.invoke!sL!tz     ' '  (''   rtcrK|jj|||fii|j|d{VSr )rrr9rrs rrrzRunnableBindingBase.ainvoke.sn(TZ'     ' '  (''         rtFrrrrrrc ttrtdfdD}n)fdtt |D}jj||fd|iij|S)Nlist[RunnableConfig]c:g|]}|Srr9rconfros rrrz-RunnableBindingBase.batch..G'>>>t$$T**>>>rtc:g|]}SrrCrrhrros rrrz-RunnableBindingBase.batch..J'OOOqt**622OOOrtr)rrrrr|rrrrorrrrrs` ` rrrzRunnableBindingBase.batch;s fd # # P&>>>>v>>>GG POOOOE#f++.^rFrtc:g|]}SrrCrHs rrrz.RunnableBindingBase.abatch..arIrtr)rrrrr|rr<rrJs` ` rrr<zRunnableBindingBase.abatchRs fd # # P&>>>>v>>>GG POOOOE#f++.rFrtc:g|]}SrrCrHs rrrz:RunnableBindingBase.batch_as_completed..rIrtr)rr rrr|rrrrJs` ` rrrz&RunnableBindingBase.batch_as_completed}sW fh ' ' P&>>>>v>>>GG POOOOE#f++.rFrtc:g|]}SrrCrHs rrrz;RunnableBindingBase.abatch_as_completed..rIrtr)rr rrr|rr?r)rorrrrrris` ` rrr?z'RunnableBindingBase.abatch_as_completeds fh ' ' P&>>>>v>>>GG POOOOE#f++BBBFBBBB8INJJJC(,++++ )-,,,, : $L/3+/ EIGK,#,#,#,#,#,#,#,#\&*6EI66666X6     XX     XX 15OOOOOOXO15PPPPPPXP '''XX'AAAAXA X[ 333X[3RRRR,0     X  ,0     X  IM #(      X ,IM #(      X ,MQ+ -2 +++++X+MQ====X=MQ #( X>MQ0 -2 00000X0MQBBBBXBMQ #( X@,0     X  ,0    X ,0    X ,0     X  ,0    X     rtr*ceZdZdZeddZe ddd Zedddd ddZe dddZeddZ ed dZ dS)!raWrap a Runnable with additional functionality. A RunnableBinding can be thought of as a "runnable decorator" that preserves the essential features of Runnable; i.e., batching, streaming, and async support, while adding additional functionality. Any class that inherits from Runnable can be bound to a `RunnableBinding`. Runnables expose a standard set of methods for creating `RunnableBindings` or sub-classes of `RunnableBindings` (e.g., `RunnableRetry`, `RunnableWithFallbacks`) that add additional functionality. These methods include: - ``bind``: Bind kwargs to pass to the underlying Runnable when running it. - ``with_config``: Bind config to pass to the underlying Runnable when running it. - ``with_listeners``: Bind lifecycle listeners to the underlying Runnable. - ``with_types``: Override the input and output types of the underlying Runnable. - ``with_retry``: Bind a retry policy to the underlying Runnable. - ``with_fallbacks``: Bind a fallback policy to the underlying Runnable. Example: `bind`: Bind kwargs to pass to the underlying Runnable when running it. .. code-block:: python # Create a Runnable binding that invokes the ChatModel with the # additional kwarg `stop=['-']` when running it. from langchain_community.chat_models import ChatOpenAI model = ChatOpenAI() model.invoke('Say "Parrot-MAGIC"', stop=['-']) # Should return `Parrot` # Using it the easy way via `bind` method which returns a new # RunnableBinding runnable_binding = model.bind(stop=['-']) runnable_binding.invoke('Say "Parrot-MAGIC"') # Should return `Parrot` Can also be done by instantiating a RunnableBinding directly (not recommended): .. code-block:: python from langchain_core.runnables import RunnableBinding runnable_binding = RunnableBinding( bound=model, kwargs={'stop': ['-']} # <-- Note the additional kwargs ) runnable_binding.invoke('Say "Parrot-MAGIC"') # Should return `Parrot` rrrcrc |||j|j|ji|j||j|jS)aBind additional kwargs to a Runnable, returning a new Runnable. Args: **kwargs: The kwargs to bind to the Runnable. Returns: A new Runnable with the same type and config as the original, but with the additional kwargs bound. )rrrrrr)rjrrrrrrrs rrrzRunnableBinding.bindEsJ~~*;!2,dk,V,"4#6    rtNrrc ||j|jtdi|j|pi||j|j|jS)Nr*r1)rjrrrrrrrrs rrrzRunnableBinding.with_configYs_~~*;(*UT[*UV\r*Uf*UVV!2"4#6    rtrrrrrcddlmdfd }||j|j|j|g|jz|j|jS) aBind lifecycle listeners to a Runnable, returning a new Runnable. Args: on_start: Called before the Runnable starts running, with the Run object. Defaults to None. on_end: Called after the Runnable finishes running, with the Run object. Defaults to None. on_error: Called if the Runnable throws an error, with the Run object. Defaults to None. Returns: The Runnable object contains information about the run, including its id, type, input, output, error, start_time, end_time, and any tags or metadata added to the run. rrrr*rcc(d|giSrrrs rrlistener_config_factoryz?RunnableBinding.with_listeners..listener_config_factorys6''%!)%!)   rtr1)rr*rcr*) rrrjrrrrrr)rorrrrdrs ``` @rrrzRunnableBinding.with_listenersis: NMMMMM         ~~*;;569NN"4#6    rtrr-rr.c||j|j|j|j||n|j||n|jS)Nr1)rjrrrrrrrs rrrzRunnableBinding.with_typessT ~~*;;!2(4 $:P +6 D.wrappersF4,T[&**Xt:T:TUU!rtc t|dzkr5t|}tj||<|i|S|dtj|ddi|S)Nrr)r|rr2rr1)rwrargslrirros rrrjz,RunnableBinding.__getattr__..wrappers4yyC!G++ $T %24;c %K%Kc #tU5f5554,T[&**Xt:T:TUU!rtr)rrrrrrrkindr KEYWORD_ONLYrPOSITIONAL_OR_KEYWORDrindex)ror` config_paramrjrirs` @@rr __getattr__zRunnableBinding.__getattr__stz4(( D>> #-d33>BB8LL LL  G$5$BBBt G$5$KKK7,T22=>>DDXNNt         rtr@r rArBrC)rr-rr.rcr)r`rdrcr) rkrrDrEr%rrrrrrrrrtrrrrs--^   X &,0     X     1 1 1 1 1 X1 f?C@D    X $   X """X"""rtrceZdZd dZdS) _RunnableCallableSync_inr<rr*rcr=cdSr rrorurs rr__call__z_RunnableCallableSync.__call__rrtN)rur<rr*rcr=rkrrDrxrrtrrrtrtsOOOOOOrtrtceZdZd dZdS) _RunnableCallableAsyncrur<rr*rcAwaitable[Output]cdSr rrws rrrxz_RunnableCallableAsync.__call__sCrtN)rur<rr*rcr|ryrrtrrr{r{s(      rtr{ceZdZd dZdS) _RunnableCallableIteratorrurwrr*rcrMcdSr rrws rrrxz"_RunnableCallableIterator.__call__s3rtN)rurwrr*rcrMryrrtrrrrs(rtrceZdZd dZdS) _RunnableCallableAsyncIteratorrur}rr*rcrPcdSr rrws rrrxz'_RunnableCallableAsyncIterator.__call__s #rtN)rur}rr*rcrPryrrtrrrrs($$$$$$rtrthingrrct|tr|St|stj|rt |St |rttd|St|trtdt|Sdt|}t|)zCoerce a Runnable-like object into a Runnable. Args: thing: A Runnable-like object. Returns: A Runnable. Raises: TypeError: If the object is not Runnable-like. rrzGExpected a Runnable, callable or dict.Instead got an unsupported type: ) rr^rIrrrrrrrrrXr~)rrs rrrrs%"" %  (G$?$F$F( '''Hd#>FFGGG%H-/?/F/FGGG :,0KK : : C..rtr.Callable[[Input], Coroutine[Any, Any, Output]]cdSr rrs rrchainr "crtrcdSr rrs rrrr$rrt(Callable[[Input], AsyncIterator[Output]]cdSr rrs rrrr*rrtrcdSr rrs rrrr0rrtUnion[Callable[[Input], Output], Callable[[Input], Iterator[Output]], Callable[[Input], Coroutine[Any, Any, Output]], Callable[[Input], AsyncIterator[Output]]]c t|S)aDecorate a function to make it a Runnable. Sets the name of the Runnable to the name of the function. Any runnables called by the function will be traced as dependencies. Args: func: A callable. Returns: A Runnable. Example: .. code-block:: python from langchain_core.runnables import chain from langchain_core.prompts import PromptTemplate from langchain_openai import OpenAI @chain def my_func(fields): prompt = PromptTemplate("Hello, {name}!") llm = OpenAI() formatted = prompt.invoke(**fields) for chunk in llm.stream(formatted): yield chunk )rrs rrrr6sH $  rt)rhrirrrcr)rrrcr)rrrcr)rrrcr)rrrcr)rrrcr)rrrcr)rE __future__rrIrrPrrryrrrcollections.abcrrrr r r r concurrent.futuresr rr itertoolsrroperatorrtypesrtypingrrrrrrrrrrrpydanticrr r!r"typing_extensionsr#r$r%langchain_core._apir& langchain_core.load.serializabler'r(r)langchain_core.runnables.configr*r+r,r-r.r/r0r1r2r3r4r5rr7langchain_core.runnables.utilsr8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIlangchain_core.utils.aiterrJrKrLlangchain_core.utils.iterrMlangchain_core.utils.pydanticrNrrOrPrrRrrTRunnableWithFallbacksTrrUlangchain_core.runnables.schemarVr*rWrhrXrYrrZlangchain_core.tracers.schemasr[r\r^rJrsrrrrdr RunnableMaprrrr rr*rrtr{rrrrrrrtrrrs //""""""########54444444""""""""                          =<<<<<<<<<<<9999999999......                            100000(@?????????------9999993?>>>>>GFFFFF;;;;;;------DCCCCC222222 h$ h$ h$ h$ h$ wuf}%sh$ h$ h$ VIA A A A A <%-)@A A A H****4,*,*,*,*^U U U U U +E6M:U U U p~~~~~+E4S>,AB~~~D g%g%g%g%g%/g%g%g%T a a a a a XeVm,a a a H+DKf,EFDm m m m m #E6M2m m m `NNNNN.uf}=NNNb GGGGG)%-8GGGTPPPPPHUF]3PPP     XeVm4    7 $$$$$XeVm%<$$$  UF] eWf_ eWi' '( huo  0 01 mE" #]6%: :;%-(5&=)eVm,"5&=1 CH   6 """ "  """ "  """ "  """ " $ $ $ $ $ $ rt