o

���g�w�@sB
dZd
dl
Z
d
dlZd
dlZd
dlZd
dlmZmZ
d
dlm	Z	
d
dl
mZmZm
Z
mZmZmZmZ
d
dlZd
dlmZ
d
dlmZmZmZmZmZmZ
d
dlmZ
d
d	lmZ
d
d
l m!Z!m"Z"m#Z#m$Z$
d
dl%m&Z&
d
dl'm(Z(m)Z)m*Z*m+Z+m,Z,
d
d
l-m.Z.
e�/e0�
Z1de2fdd�Z3Gdd�de"ee4efee4effe�Z5dS)z0Base interface that all chains should implement.�N)�ABC�abstractmethod)
�Path)�Any�Dict�List�Optional�Type�Union�cast)
�
deprecated)�AsyncCallbackManager�AsyncCallbackManagerForChainRun�BaseCallbackManager�CallbackManager�CallbackManagerForChainRun�	Callbacks)
�
BaseMemory)
�RunInfo)�RunnableConfig�RunnableSerializable�
ensure_config�run_in_executor)
�create_model)�	BaseModel�
ConfigDict�Field�field_validator�model_validator)
�RUN_KEY�returnc
Csd
dlm
}
|�S)Nr
�
�get_verbose)�langchain.globalsr"r!�r$�@/usr/local/lib/python3.10/dist-packages/langchain/chains/base.py�_get_verbosity+s
r&cs8eZ
dZUd
ZdZeeed<	eddd�Z	e
ed<	eed�
Ze
ed<	dZeeeed	<	dZeeeefed
<	eddd�Zeeed<	edd�
Z	dXd
eedeefdd�Z	dXd
eedeefdd�Z	dXdeeefd
eededeeeffdd�Z	dXdeeefd
eededeeeffdd�Zedefdd��
Z e!dd�
e"dedefdd��
�
Z#e$ddd�e"dee
de
fd d!��
�
Z%ee&deefd"d#��
�
Z'ee&deefd$d%��
�
Z(d&eeefddfd'd(�Z)d)eeefddfd*d+�Z*e&	dXd&eeefd,ee+deeeffd-d.��
Z,	dXd&eeefd,ee-deeeffd/d0�Z.e/d1d2d3d4�	5	dYdddd5d6�d&e0eeefefd7e
de
d	eeed
eeeefd8eed9e
deeeffd:d;��
Z1e/d1d<d3d4�	5	dYdddd5d6�d&e0eeefefd7e
de
d	eeed
eeeefd8eed9e
deeeffd=d>��
Z2	5dZd&eeefd)eeefd7e
deeeffd?d@�Z3	5dZd&eeefd)eeefd7e
deeeffdAdB�Z4d&e0eeefefdeeeffdCdD�Z5d&e0eeefefdeeeffdEdF�Z6edefdGdH��
Z7e/d1d2d3d4�ddddI�dJede
d	eeed
eeeefdedefdKdL��
Z8e/d1d<d3d4�ddddI�dJede
d	eeed
eeeefdedefdMdN��
Z9dedef�f
dOdP�Z:dQe0e;efddfdRdS�Z<e/d1dTd3d4�	dXdUeeeefde
deeeeffdVdW��
Z=�Z>S)[�Chaina�Abstract base class for creating structured sequences of calls to components.

    Chains should be used to encode a sequence of calls to components like
    models, document retrievers, other chains, etc., and provide a simple interface
    to this sequence.

    The Chain interface makes it easy to create apps that are:
        - Stateful: add Memory to any Chain to give it state,
        - Observable: pass Callbacks to a Chain to execute additional functionality,
            like logging, outside the main sequence of component calls,
        - Composable: the Chain API is flexible enough that it is easy to combine
            Chains with other components, including other Chains.

    The main methods exposed by chains are:
        - `__call__`: Chains are callable. The `__call__` method is the primary way to
            execute a Chain. This takes inputs as a dictionary and returns a
            dictionary output.
        - `run`: A convenience method that takes inputs as args/kwargs and returns the
            output as a string or object. This method can only be used for a subset of
            chains and cannot return as rich of an output as `__call__`.
    N�memoryT)�default�exclude�	callbacks)
�default_factory�verbose�tags�metadata�callback_manager)
�arbitrary_types_allowed�configr cC�t	
didd�|j
D�
�
�
S)N�
ChainInputc
S�i|]}
|
tdf�qS�
N�
r��.0�
kr$r$r%�
<dictcomp>q�z*Chain.get_input_schema.<locals>.<dictcomp>)
r4)r�
input_keys��selfr2r$r$r%�get_input_schemal�

�
�zChain.get_input_schemacCr3)N�ChainOutputc
Sr5r6r7r8r$r$r%r;yr<z+Chain.get_output_schema.<locals>.<dictcomp>)
rB)r�output_keysr>r$r$r%�get_output_schematrAzChain.get_output_schema�input�kwargsc
Ks*
t|�
}|�
d
�
}|�
d�
}|�
d�
}|�
d�
p|��}|�
d�
}|�
dd�}	|�
dd�}
|�|
�
}t�||j|j||j||j	�}t
�|j�
j
�
d	�
}
|jd|||d
�}z|�|�

|
rc|j||d�n|�|�
}|�|||
�}Wnty�
}
z|�|�

|�
d}~w
w|�|�

|	r�t|jd�
|t<|S�
Nr+r.r/�run_name�run_id�include_run_infoF�return_only_outputs�run_manager)
�name)
rL)
rI)r�get�get_name�prep_inputsr�	configurer+r-r.r/�inspect�	signature�_call�
parameters�on_chain_start�_validate_inputs�prep_outputs�
BaseException�on_chain_error�on_chain_endrrIr�r?rEr2rFr+r.r/rHrIrJrK�inputsr0�new_arg_supportedrL�outputs�
final_outputs�
er$r$r%�invoke|sV



















�	



�

��
�


��


zChain.invokec
�sV
�
t|�
}|�
d
�
}|�
d�
}|�
d�
}|�
d�
p|��}|�
d�
}|�
dd�}	|�
dd�}
|�|
�
IdH}t�||j|j||j||j	�}t
�|j�
j
�
d	�
}
|jd|||d
�IdH}z%|�|�

|
rm|j||d�IdHn|�|�
IdH}|�|||
�IdH}Wnty�
}
z
|�|�
IdH
|�
d}~w
w|�|�
IdH
|	r�t|jd�
|t<|SrG)rrNrO�aprep_inputsr
rQr+r-r.r/rRrS�_acallrUrVrW�
aprep_outputsrYrZr[rrIrr\r$r$r%�ainvoke�sX�


















�	




�

��
�

��

z
Chain.ainvokec

Cstd
�
�
)Nz)Saving not supported for this chain type.)
�NotImplementedError�
r?r$r$r%�_chain_type�szChain._chain_type�before)
�mode�valuescCsD|
�d
�
du
r |
�d�
du
rt
d�
�
t�dt�
|
�d
d�|
d<|
S)z6Raise deprecation warning if callback_manager is used.r0Nr+z�Cannot specify both callback_manager and callbacks. callback_manager is deprecated, callbacks is the preferred parameter to pass in.z=callback_manager is deprecated. Please use callbacks instead.)rN�
ValueError�warnings�warn�DeprecationWarning�pop)�clsrlr$r$r%�"raise_callback_manager_deprecation�s


�

�
z(Chain.raise_callback_manager_deprecationcCs|
d
urt�S|
S)zgSet the chain verbosity.

        Defaults to the global setting if not specified by the user.
        N)
r&)rrr-r$r$r%�set_verbose�s
zChain.set_verbosec


C�d
S)z'Keys expected to be in the chain input.Nr$rhr$r$r%r=
�zChain.input_keysc


Cru)z(Keys expected to be in the chain output.Nr$rhr$r$r%rC
rvzChain.output_keysr]cCsnt|
t
�s$t|j�
}|jd
u
r|�|jj�
}t|�
dkr$td|�d��
�
t|j�
�|
�
}|r5td|���
�
d
S)z"Check that all inputs are present.N�
zMA single string input was passed in, but this chain expects multiple inputs (zt). When a chain expects multiple inputs, please call it by passing in a dictionary, eg `chain({'foo': 1, 'bar': 2})`zMissing some input keys: )	�
isinstance�dict�setr=r(�
difference�memory_variables�lenrm)r?r]�_input_keys�missing_keysr$r$r%rW
s








��

�zChain._validate_inputsr_cCs&t|j
�
�|
�
}|rtd
|���
�
dS)NzMissing some output keys: )rzrCr{rm)r?r_rr$r$r%�_validate_outputs$
s


�zChain._validate_outputsrLc
Cru)a�Execute the chain.

        This is a private method that is not user-facing. It is only called within
            `Chain.__call__`, which is the user-facing wrapper method that handles
            callbacks configuration and some input/output processing.

        Args:
            inputs: A dict of named inputs to the chain. Assumed to contain all inputs
                specified in `Chain.input_keys`, including any inputs added by memory.
            run_manager: The callbacks manager that contains the callback handlers for
                this run of the chain.

        Returns:
            A dict of named outputs. Should contain all outputs specified in
                `Chain.output_keys`.
        Nr$�r?r]rLr$r$r%rT)
rvzChain._callc�s$�
td
|j
|
|r|��n
d
�Id
HS)a�Asynchronously execute the chain.

        This is a private method that is not user-facing. It is only called within
            `Chain.acall`, which is the user-facing wrapper method that handles
            callbacks configuration and some input/output processing.

        Args:
            inputs: A dict of named inputs to the chain. Assumed to contain all inputs
                specified in `Chain.input_keys`, including any inputs added by memory.
            run_manager: The callbacks manager that contains the callback handlers for
                this run of the chain.

        Returns:
            A dict of named outputs. Should contain all outputs specified in
                `Chain.output_keys`.
        N)rrT�get_syncr�r$r$r%rd@
s�

�zChain._acallz0.1.0rbz1.0)�alternative�removalF)r.r/rHrJrKrHrJc	Cs4||||d
�}|j|
t
tdd�|��D�
�||d�S)a�Execute the chain.

        Args:
            inputs: Dictionary of inputs, or single input if chain expects
                only one param. Should contain all inputs specified in
                `Chain.input_keys` except for inputs that will be set by the chain's
                memory.
            return_only_outputs: Whether to return only outputs in the
                response. If True, only new keys generated by this chain will be
                returned. If False, both input keys and new keys generated by this
                chain will be returned. Defaults to False.
            callbacks: Callbacks to use for this chain run. These will be called in
                addition to callbacks passed to the chain during construction, but only
                these runtime callbacks will propagate to calls to other objects.
            tags: List of string tags to pass to all callbacks. These will be passed in
                addition to tags passed to the chain during construction, but only
                these runtime tags will propagate to calls to other objects.
            metadata: Optional metadata associated with the chain. Defaults to None
            include_run_info: Whether to include run info in the response. Defaults
                to False.

        Returns:
            A dict of named outputs. Should contain all outputs specified in
                `Chain.output_keys`.
        �r+r.r/rHc
Ssi|]\}
}|du
r|
|�qSr6r$�r9r:�
vr$r$r%r;�
�z"Chain.__call__.<locals>.<dictcomp>�rKrJ)rbrr�items�	r?r]rKr+r.r/rHrJr2r$r$r%�__call__Y
s&


�



�zChain.__call__rfc	�s<�
||||d
�}|j|
t
tdd�|��D�
�||d�IdHS)a�Asynchronously execute the chain.

        Args:
            inputs: Dictionary of inputs, or single input if chain expects
                only one param. Should contain all inputs specified in
                `Chain.input_keys` except for inputs that will be set by the chain's
                memory.
            return_only_outputs: Whether to return only outputs in the
                response. If True, only new keys generated by this chain will be
                returned. If False, both input keys and new keys generated by this
                chain will be returned. Defaults to False.
            callbacks: Callbacks to use for this chain run. These will be called in
                addition to callbacks passed to the chain during construction, but only
                these runtime callbacks will propagate to calls to other objects.
            tags: List of string tags to pass to all callbacks. These will be passed in
                addition to tags passed to the chain during construction, but only
                these runtime tags will propagate to calls to other objects.
            metadata: Optional metadata associated with the chain. Defaults to None
            include_run_info: Whether to include run info in the response. Defaults
                to False.

        Returns:
            A dict of named outputs. Should contain all outputs specified in
                `Chain.output_keys`.
        r�c
Ssi|]\}
}|
du
r|
|�qSr6r$r�r$r$r%r;�
r�zChain.acall.<locals>.<dictcomp>r�N)rfrrr�r�r$r$r%�acall�
s�&


�



�zChain.acallcCs6|�|�

|j
d
u
r|j
�|
|�
|r|Si|
�
|�
S�a�
Validate and prepare chain outputs, and save info about this run to memory.

        Args:
            inputs: Dictionary of chain inputs, including any inputs added by chain
                memory.
            outputs: Dictionary of initial chain outputs.
            return_only_outputs: Whether to only return the chain outputs. If False,
                inputs are also added to the final outputs.

        Returns:
            A dict of the final chain outputs.
        N)r�r(�save_context�r?r]r_rKr$r$r%rX�
s





zChain.prep_outputsc�s>�
|�|�

|j
d
u
r|j
�|
|�Id
H
|r|Si|
�
|�
Sr�)r�r(�
asave_contextr�r$r$r%re�
s�





zChain.aprep_outputscCsft|
t
�st|j�
}|jd
u
r|�|jj�
}t|�
d|
i
}
|jd
u
r1|j�|
�
}t
|
f
i|�
�
}
|
S�a�
Prepare chain inputs, including adding inputs from memory.

        Args:
            inputs: Dictionary of raw inputs, or single input if chain expects
                only one param. Should contain all inputs specified in
                `Chain.input_keys` except for inputs that will be set by the chain's
                memory.

        Returns:
            A dictionary of all inputs, including those added by the chain's memory.
        Nr
)	rxryrzr=r(r{r|�list�load_memory_variables�r?r]r~�external_contextr$r$r%rP�
s










zChain.prep_inputsc�sn�
t|
t
�st|j�
}|jd
u
r|�|jj�
}t|�
d|
i
}
|jd
u
r5|j�|
�
Id
H}t
|
f
i|�
�
}
|
Sr�)	rxryrzr=r(r{r|r��aload_memory_variablesr�r$r$r%rc
s�










zChain.aprep_inputsc

Cs*t|j
�
d
krtd|j
�d��
�
|j
dS)Nrw�B`run` not supported when there is not exactly one output key. Got �
.r
)r}rCrmrhr$r$r%�_run_output_key"s


��
zChain._run_output_key�r+r.r/�argsc
Os||j}|r|st
|�
d
krtd�
�
||d|
||d�|S|r+|s+|||
||d�|S|s3|s3td�
�
td|�d|�d��
�
)	aConvenience method for executing chain.

        The main difference between this method and `Chain.__call__` is that this
        method expects inputs to be passed directly in as positional arguments or
        keyword arguments, whereas `Chain.__call__` expects a single input dictionary
        with all the inputs

        Args:
            *args: If the chain expects a single input, it can be passed in as the
                sole positional argument.
            callbacks: Callbacks to use for this chain run. These will be called in
                addition to callbacks passed to the chain during construction, but only
                these runtime callbacks will propagate to calls to other objects.
            tags: List of string tags to pass to all callbacks. These will be passed in
                addition to tags passed to the chain during construction, but only
                these runtime tags will propagate to calls to other objects.
            **kwargs: If the chain expects multiple inputs, they can be passed in
                directly as keyword arguments.

        Returns:
            The chain output.

        Example:
            .. code-block:: python

                # Suppose we have a single-input chain that takes a 'question' string:
                chain.run("What's the temperature in Boise, Idaho?")
                # -> "The temperature in Boise is..."

                # Suppose we have a multi-input chain that takes a 'question' string
                # and 'context' string:
                question = "What's the temperature in Boise, Idaho?"
                context = "Weather report for Boise, Idaho on 07/03/23..."
                chain.run(question=question, context=context)
                # -> "The temperature in Boise is..."
        rw�,`run` supports only one positional argument.r
r�z^`run` supported with either positional arguments or keyword arguments, but none were provided.�^`run` supported with either positional arguments or keyword arguments but not both. Got args: �
 and kwargs: r�)r�r}rm)r?r+r.r/r�rF�_output_keyr$r$r%�run+s,.



�

�

�

�
��z	Chain.runc
�s��
t|j
�
d
krtd|j
�d��
�
|r2|s2t|�
d
krtd�
�
|j|d|
||d�IdH|j
dS|rG|sG|j||
||d�IdH|j
dStd|�d	|�d��
�
)
aConvenience method for executing chain.

        The main difference between this method and `Chain.__call__` is that this
        method expects inputs to be passed directly in as positional arguments or
        keyword arguments, whereas `Chain.__call__` expects a single input dictionary
        with all the inputs


        Args:
            *args: If the chain expects a single input, it can be passed in as the
                sole positional argument.
            callbacks: Callbacks to use for this chain run. These will be called in
                addition to callbacks passed to the chain during construction, but only
                these runtime callbacks will propagate to calls to other objects.
            tags: List of string tags to pass to all callbacks. These will be passed in
                addition to tags passed to the chain during construction, but only
                these runtime tags will propagate to calls to other objects.
            **kwargs: If the chain expects multiple inputs, they can be passed in
                directly as keyword arguments.

        Returns:
            The chain output.

        Example:
            .. code-block:: python

                # Suppose we have a single-input chain that takes a 'question' string:
                await chain.arun("What's the temperature in Boise, Idaho?")
                # -> "The temperature in Boise is..."

                # Suppose we have a multi-input chain that takes a 'question' string
                # and 'context' string:
                question = "What's the temperature in Boise, Idaho?"
                context = "Weather report for Boise, Idaho on 07/03/23..."
                await chain.arun(question=question, context=context)
                # -> "The temperature in Boise is..."
        rwr�r�r�r
r�Nr�r�)r}rCrmr�)r?r+r.r/r�rFr$r$r%�arunrs8�.


��



��

��

�
��z
Chain.arunc
s8t�j
di|
�
�
}z|j|d
<W|Sty


Y|Sw)a�
Dictionary representation of chain.

        Expects `Chain._chain_type` property to be implemented and for memory to be
            null.

        Args:
            **kwargs: Keyword arguments passed to default `pydantic.BaseModel.dict`
                method.

        Returns:
            A dictionary representation of the chain.

        Example:
            .. code-block:: python

                chain.dict(exclude_unset=True)
                # -> {"_type": "foo", "verbose": False, ...}
        �_typeNr$)�superryrirg)r?rF�_dict�
�	__class__r$r%ry�s

�

�z
Chain.dict�	file_pathcCs
|jd
u
r	t
d�
�
|��}d|v
rtd|�d��
�
t|
t�r#t|
�
}n|
}|j}|jddd�
|j	dkrTt
|
d	��}tj||d
d�
Wd
�
d
S1sMw



Y
d
S|j	�
d�
rzt
|
d	��}tj||d
d�
Wd
�
d
S1ssw



Y
d
St
|�d��
�
)a6
Save the chain.

        Expects `Chain._chain_type` property to be implemented and for memory to be
            null.

        Args:
            file_path: Path to file to save the chain to.

        Example:
            .. code-block:: python

                chain.save(file_path="path/chain.yaml")
        Nz&Saving of memory is not yet supported.r�zChain z does not support saving.T)�parents�exist_okz.json�
w�)
�indent)z.yamlz.ymlF)
�default_flow_stylez must be json or yaml)r(rmryrgrx�strr�parent�mkdir�suffix�open�json�dump�endswith�yaml)r?r��
chain_dict�	save_path�directory_path�
fr$r$r%�save�s&










"�

"�z
Chain.save�batch�
input_listcs��
fd
d�|
D�
S)z)Call the chain on all inputs in the list.c
sg|]}
�
|
�d��qS)
)
r+r$)r9r]�r+r?r$r%�
<listcomp>
szChain.apply.<locals>.<listcomp>r$)r?r�r+r$r�r%�apply�szChain.applyr6)FN)
F)?�__name__�
__module__�__qualname__�__doc__r(rr�__annotations__rr+rr&r-�boolr.rr�r/rrr0rr�model_configrr	rr@rDrbrf�propertyrir�classmethodrsrrtrr=rCrWr�rrTrrdrr
r�r�rXrerPrcr�r�r�ryrr�r��
__classcell__r$r$r�r%r'1s�









��
�
�	�
�
��
���

�8�
���

�3










�
��
��
��

�
�


����
���	�

�2
�


����
���	�

�5�
�
��

��
�
��

�**


���
����F

���
����G(�
�
��r')6r�rRr��loggingrn�abcrr�pathlibr�typingrrrrr	r
rr��langchain_core._apir�langchain_core.callbacksr
rrrrr�langchain_core.memoryr�langchain_core.outputsr�langchain_core.runnablesrrrr�langchain_core.runnables.utilsr�pydanticrrrrr�langchain.schemar�	getLoggerr��loggerr�r&r�r'r$r$r$r%�<module>
s(




$

 




.