a
    ”˜ëj±_  ã                   @   s,  d Z ddlZddlZddlZddlmZmZmZ ddlm	Z	 ddlm
Z
mZmZmZmZ ddlmZmZ ddlmZ ddlmZmZ dd	lmZmZ dd
lmZmZmZmZmZm Z m!Z! ddl"m#Z#m$Z$m%Z%m&Z&m'Z' ddl(m)Z) e
rðddlm*Z* G dd„ dee$e%f ƒZ+ee,dœdd„Z-ee,dœdd„Z.dS )z:Runnable that can fallback to other Runnables if it fails.é    N)ÚAsyncIteratorÚIteratorÚSequence)Úwraps)ÚTYPE_CHECKINGÚAnyÚOptionalÚUnionÚcast)Ú	BaseModelÚ
ConfigDict)Úoverride)ÚAsyncCallbackManagerÚCallbackManager)ÚRunnableÚRunnableSerializable)ÚRunnableConfigÚensure_configÚ%get_async_callback_manager_for_configÚget_callback_manager_for_configÚget_config_listÚpatch_configÚset_config_context)ÚConfigurableFieldSpecÚInputÚOutputÚcoro_with_contextÚget_unique_config_specs)Úpy_anext)ÚAsyncCallbackManagerForChainRunc                	   @   sZ  e Zd ZU dZeeef ed< eeeef  ed< e	fZ
eee df ed< dZee ed< edd	�Zeeee d
œdd„ƒƒZeeee d
œdd„ƒƒZed/ee ee dœdd„ƒZed0ee ee dœdd„ƒZeeee d
œdd„ƒƒZeeed
œdd„ƒƒZ eeee d
œdd„ƒƒZ!ee"eeef  d
œdd„ƒZ#ed1eee e$edœdd„ƒZ%ed2eee ee$ edœdd „ƒZ&ed3d!d"œee ee'eee f  eee$ ee d#œd$d%„ƒZ(ed4d!d"œee ee'eee f  eee$ ee d#œd&d'„ƒZ)ed5eee ee$ e"e dœd(d)„ƒZ*ed6eee ee$ e+e dœd*d+„ƒZ,ee$d,œd-d.„Z-dS )7ÚRunnableWithFallbacksuÍ  Runnable that can fallback to other Runnables if it fails.

    External APIs (e.g., APIs for a language model) may at times experience
    degraded performance or even downtime.

    In these cases, it can be useful to have a fallback Runnable that can be
    used in place of the original Runnable (e.g., fallback to another LLM provider).

    Fallbacks can be defined at the level of a single Runnable, or at the level
    of a chain of Runnables. Fallbacks are tried in order until one succeeds or
    all fail.

    While you can instantiate a ``RunnableWithFallbacks`` directly, it is usually
    more convenient to use the ``with_fallbacks`` method on a Runnable.

    Example:

        .. code-block:: python

            from langchain_core.chat_models.openai import ChatOpenAI
            from langchain_core.chat_models.anthropic import ChatAnthropic

            model = ChatAnthropic(model="claude-3-haiku-20240307").with_fallbacks(
                [ChatOpenAI(model="gpt-3.5-turbo-0125")]
            )
            # Will usually use ChatAnthropic, but fallback to ChatOpenAI
            # if ChatAnthropic fails.
            model.invoke("hello")

            # And you can also use fallbacks at the level of a chain.
            # Here if both LLM providers fail, we'll fallback to a good hardcoded
            # response.

            from langchain_core.prompts import PromptTemplate
            from langchain_core.output_parser import StrOutputParser
            from langchain_core.runnables import RunnableLambda


            def when_all_is_lost(inputs):
                return (
                    "Looks like our LLM providers are down. "
                    "Here's a nice ðŸ¦œï¸� emoji for you instead."
                )


            chain_with_fallback = (
                PromptTemplate.from_template("Tell me a joke about {topic}")
                | model
                | StrOutputParser()
            ).with_fallbacks([RunnableLambda(when_all_is_lost)])

    ÚrunnableÚ	fallbacks.Úexceptions_to_handleNÚexception_keyT)Zarbitrary_types_allowed)Úreturnc                 C   s   | j jS ©N)r!   Ú	InputType©Úself© r*   úa/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/langchain_core/runnables/fallbacks.pyr'   n   s    zRunnableWithFallbacks.InputTypec                 C   s   | j jS r&   )r!   Ú
OutputTyper(   r*   r*   r+   r,   s   s    z RunnableWithFallbacks.OutputType)Úconfigr%   c                 C   s   | j  |¡S r&   )r!   Úget_input_schema©r)   r-   r*   r*   r+   r.   x   s    z&RunnableWithFallbacks.get_input_schemac                 C   s   | j  |¡S r&   )r!   Úget_output_schemar/   r*   r*   r+   r0   ~   s    z'RunnableWithFallbacks.get_output_schemac                 C   s   t dd„ | jg| j¢D ƒƒS )Nc                 s   s   | ]}|j D ]
}|V  qqd S r&   )Úconfig_specs)Ú.0ÚstepÚspecr*   r*   r+   Ú	<genexpr>‡   s   
þz5RunnableWithFallbacks.config_specs.<locals>.<genexpr>)r   r!   r"   r(   r*   r*   r+   r1   „   s    þz"RunnableWithFallbacks.config_specsc                 C   s   dS )z*Return True as this class is serializable.Tr*   ©Úclsr*   r*   r+   Úis_lc_serializable�   s    z(RunnableWithFallbacks.is_lc_serializablec                 C   s   g d¢S )zyGet the namespace of the langchain object.

        Returns:
            ``["langchain", "schema", "runnable"]``
        )Z	langchainZschemar!   r*   r6   r*   r*   r+   Úget_lc_namespace“   s    z&RunnableWithFallbacks.get_lc_namespacec                 c   s   | j V  | jE dH  dS )ztIterator over the Runnable and its fallbacks.

        Yields:
            The Runnable then its fallbacks.
        N©r!   r"   r(   r*   r*   r+   Ú	runnables�   s    zRunnableWithFallbacks.runnables)Úinputr-   Úkwargsr%   c                 K   sŠ  | j d ur,t|tƒs,dt|ƒ› d�}t|ƒ‚t|ƒ}t|ƒ}|jd || d¡pT|  	¡ | 
dd ¡d�}d }d }| jD ]î}	zl| j r�|d ur�||| j < t|| ¡ d�}
t|
ƒ�(}|j|	j||fi |¤Ž}W d   ƒ n1 sÖ0    Y  W nj | j�y } z|d u �r|}|}W Y d }~qrd }~0  t�yL } z| |¡ ‚ W Y d }~qrd }~0 0 | |¡ |  S qr|d u �rxd}t|ƒ‚| |¡ |‚d S ©NúXIf 'exception_key' is specified then input must be a dictionary.However found a type of ú
 for inputÚrun_nameÚrun_id©ÚnamerB   ©Ú	callbacksz$No error stored at end of fallbacks.)r$   Ú
isinstanceÚdictÚtypeÚ
ValueErrorr   r   Úon_chain_startÚgetÚget_nameÚpopr;   r   Ú	get_childr   ÚrunÚinvoker#   ÚBaseExceptionÚon_chain_errorÚon_chain_end)r)   r<   r-   r=   ÚmsgÚcallback_managerÚrun_managerÚfirst_errorÚ
last_errorr!   Úchild_configÚcontextÚoutputÚer*   r*   r+   rQ   §   sV    ÿÿ
ü


ýü(





zRunnableWithFallbacks.invokec                 Ë   s´  | j d ur,t|tƒs,dt|ƒ› d�}t|ƒ‚t|ƒ}t|ƒ}|jd || d¡pT|  	¡ | 
dd ¡d�I d H }d }d }| jD �]
}	z|| j r˜|d ur˜||| j < t|| ¡ d�}
t|
ƒ�8}|j|	j||fi |¤Ž}t||ƒI d H }W d   ƒ n1 sî0    Y  W np | j�y4 } z|d u �r|}|}W Y d }~qxd }~0  t�yj } z| |¡I d H  ‚ W Y d }~qxd }~0 0 | |¡I d H  |  S qx|d u �rœd}t|ƒ‚| |¡I d H  |‚d S r>   )r$   rG   rH   rI   rJ   r   r   rK   rL   rM   rN   r;   r   rO   r   rP   Úainvoker   r#   rR   rS   rT   )r)   r<   r-   r=   rU   rV   rW   rX   rY   r!   rZ   r[   Úcoror\   r]   r*   r*   r+   r^   Ù   sL    ÿÿ
ü

2


zRunnableWithFallbacks.ainvokeF)Úreturn_exceptions)Úinputsr-   r`   r=   r%   c                   s
  ˆj d ur8tdd„ |D ƒƒs8dt|d ƒ› d�}t|ƒ‚|s@g S t|t|ƒƒ‰ dd„ ˆ D ƒ}‡fdd„t||ˆ ƒD ƒ‰i }tt|ƒƒ}i }	d }
ˆj	D �]}|j
d	d„ t| ¡ ƒD ƒ‡ ‡fd
d„t|ƒD ƒfddi|¤Ž}tt| ¡  ¡ ƒ|ƒD ]¢\\}}}t|tƒ�r:t|ˆjƒ�s:|�s&|
�p"|}
n||	|< | |¡ qît|ˆjƒ�rdˆj �rZ||ˆj < ||	|< qîˆ|  |¡ |||< | |¡ |	 |d ¡ qî|
�rœ|
‚|s” �q¨q”t|	 ¡ ƒ}|D ]\}}ˆ|  |¡ �q¸|�sê|�rê|d d ‚| |	¡ dd„ t| ¡ ƒD ƒS )Nc                 s   s   | ]}t |tƒV  qd S r&   ©rG   rH   ©r2   Úinput_r*   r*   r+   r5     s   z.RunnableWithFallbacks.batch.<locals>.<genexpr>úYIf 'exception_key' is specified then inputs must be dictionaries.However found a type of r   r@   c                 S   s6   g | ].}t j| d ¡dd| d¡d| d¡dd�‘qS ©rF   NFÚtagsÚmetadata)Zinheritable_callbacksZlocal_callbacksÚverboseZinheritable_tagsZ
local_tagsZinheritable_metadataZlocal_metadata)r   Ú	configurerL   ©r2   r-   r*   r*   r+   Ú
<listcomp>"  s   
÷ùz/RunnableWithFallbacks.batch.<locals>.<listcomp>c              
      sL   g | ]D\}}}|j d t|tƒr"|nd|i| d¡p8ˆ  ¡ | dd ¡d�‘qS )Nr<   rA   rB   rC   )rK   rG   rH   rL   rM   rN   ©r2   Úcmrd   r-   r(   r*   r+   rl   /  s   ú
üc                 S   s   g | ]\}}|‘qS r*   r*   ©r2   Ú_rd   r*   r*   r+   rl   ?  ó    c                    s$   g | ]}t ˆ | ˆ|  ¡ d �‘qS ©rE   ©r   rO   ©r2   Úi©ÚconfigsÚrun_managersr*   r+   rl   @  s   ÿr`   Té   c                 S   s   g | ]\}}|‘qS r*   r*   ©r2   rp   r\   r*   r*   r+   rl   e  rq   )r$   ÚallrI   rJ   r   ÚlenÚziprH   Ú	enumerater;   ÚbatchÚsortedÚitemsÚcopyrG   rR   r#   rN   rT   rS   Úupdate)r)   ra   r-   r`   r=   rU   Úcallback_managersÚ	to_returnÚ	run_againÚhandled_exceptionsÚfirst_to_raiser!   Úoutputsru   rd   r\   Úsorted_handled_exceptionsÚerrorr*   ©rw   rx   r)   r+   r     sv    	ÿ
ÿÿ
ö

ù
ýþùø
"ÿ



zRunnableWithFallbacks.batchc                ‹   s$  ˆj d ur8tdd„ |D ƒƒs8dt|d ƒ› d�}t|ƒ‚|s@g S t|t|ƒƒ‰ dd„ ˆ D ƒ}tj‡fdd„t||ˆ ƒD ƒŽ I d H ‰i }t	t
|ƒƒ}i }	d }
ˆjD �]}|jd	d„ t| ¡ ƒD ƒ‡ ‡fd
d„t|ƒD ƒfddi|¤ŽI d H }tt| ¡  ¡ ƒ|ƒD ]ª\\}}}t|tƒ�rLt|ˆjƒ�sL|�s8|
�p4|}
n||	|< | |¡ n\t|ˆjƒ�rvˆj �rl||ˆj < ||	|< n2|||< ˆ|  |¡I d H  | |¡ |	 |d ¡ �q |
�r¶|
‚|s  �qÂq t|	 ¡ ƒ}tj‡fdd„|D ƒŽ I d H  |�s|�r|d d ‚| |	¡ dd„ t| ¡ ƒD ƒS )Nc                 s   s   | ]}t |tƒV  qd S r&   rb   rc   r*   r*   r+   r5   p  s   z/RunnableWithFallbacks.abatch.<locals>.<genexpr>re   r   r@   c                 S   s6   g | ].}t j| d ¡dd| d¡d| d¡dd�‘qS rf   )r   rj   rL   rk   r*   r*   r+   rl   ~  s   
÷ùz0RunnableWithFallbacks.abatch.<locals>.<listcomp>c              	   3   s<   | ]4\}}}|j d || d¡p$ˆ  ¡ | dd ¡d�V  qd S )NrA   rB   rC   )rK   rL   rM   rN   rm   r(   r*   r+   r5   Œ  s   ú
üc                 S   s   g | ]\}}|‘qS r*   r*   ro   r*   r*   r+   rl   �  rq   c                    s$   g | ]}t ˆ | ˆ|  ¡ d �‘qS rr   rs   rt   rv   r*   r+   rl   ž  s   ÿr`   Tc                 3   s    | ]\}}ˆ |   |¡V  qd S r&   )rS   )r2   ru   r‹   )rx   r*   r+   r5   Á  s   ÿry   c                 S   s   g | ]\}}t d |ƒ‘qS )r   )r
   rz   r*   r*   r+   rl   É  rq   )r$   r{   rI   rJ   r   r|   ÚasyncioZgatherr}   rH   r~   r;   Úabatchr€   r�   r‚   rG   rR   r#   rN   rT   rƒ   )r)   ra   r-   r`   r=   rU   r„   r…   r†   r‡   rˆ   r!   r‰   ru   rd   r\   rŠ   r*   rŒ   r+   rŽ   g  s€    	ÿ
ÿÿ
ö

ùÿ
ýþùø"ÿ



þÿ

zRunnableWithFallbacks.abatchc                 k   s  | j d ur,t|tƒs,dt|ƒ› d�}t|ƒ‚t|ƒ}t|ƒ}|jd || d¡pT|  	¡ | 
dd ¡d�}d }d }| jD ]ô}	zv| j r�|d ur�||| j < t|| ¡ d�}
t|
ƒ�2}|j|	j|fi |¤Ž}| t|¡}W d   ƒ n1 sà0    Y  W nn | j�y* } z"|d u �r|n|}|}W Y d }~qrd }~0  t�yZ } z| |¡ ‚ W Y d }~qrd }~0 0 d } �qhqr|�r|| |¡ |‚|V  |}z<|D ]2}|V  z|| }W n t�yº   d }Y n0 �qŒW n2 t�yô } z| |¡ ‚ W Y d }~n
d }~0 0 | |¡ d S ©Nr?   r@   rA   rB   rC   rE   )r$   rG   rH   rI   rJ   r   r   rK   rL   rM   rN   r;   r   rO   r   rP   ÚstreamÚnextr#   rR   rS   Ú	TypeErrorrT   ©r)   r<   r-   r=   rU   rV   rW   rX   rY   r!   rZ   r[   r�   Úchunkr]   r\   r*   r*   r+   r�   Ë  sj    ÿÿ
ü


þý.


zRunnableWithFallbacks.streamc                 K  s4  | j d ur,t|tƒs,dt|ƒ› d�}t|ƒ‚t|ƒ}t|ƒ}|jd || d¡pT|  	¡ | 
dd ¡d�I d H }d }d }| jD �] }	z|| j r˜|d ur˜||| j < t|| ¡ d�}
t|
ƒ�8}|	j||
fi |¤Ž}tt|ƒ|ƒI d H }W d   ƒ n1 sî0    Y  W nt | j�y8 } z"|d u �r|n|}|}W Y d }~qxd }~0  t�yn } z| |¡I d H  ‚ W Y d }~qxd }~0 0 d } �q|qx|�r–| |¡I d H  |‚|V  |}zF|2 z:3 d H W }|V  z|| }W n t�yÜ   d }Y n0 �q¦6 W n8 t�y } z| |¡I d H  ‚ W Y d }~n
d }~0 0 | |¡I d H  d S r�   )r$   rG   rH   rI   rJ   r   r   rK   rL   rM   rN   r;   r   rO   r   Úastreamr   r   r#   rR   rS   r’   rT   r“   r*   r*   r+   r•     sj    ÿÿ
ü

þý6zRunnableWithFallbacks.astream)rD   r%   c                    s>   t ˆjˆƒ‰ tˆ ƒr:tˆ ƒtttdœ‡ ‡‡fdd„ƒ}|S ˆ S )a‡  Get an attribute from the wrapped Runnable and its fallbacks.

        Returns:
            If the attribute is anything other than a method that outputs a Runnable,
            returns getattr(self.runnable, name). If the attribute is a method that
            does return a new Runnable (e.g. llm.bind_tools([...]) outputs a new
            RunnableBinding) then self.runnable and each of the runnables in
            self.fallbacks is replaced with getattr(x, name).

        Example:
            .. code-block:: python

                from langchain_openai import ChatOpenAI
                from langchain_anthropic import ChatAnthropic

                gpt_4o = ChatOpenAI(model="gpt-4o")
                claude_3_sonnet = ChatAnthropic(model="claude-3-7-sonnet-20250219")
                llm = gpt_4o.with_fallbacks([claude_3_sonnet])

                llm.model_name
                # -> "gpt-4o"

                # .bind_tools() is called on both ChatOpenAI and ChatAnthropic
                # Equivalent to:
                # gpt_4o.bind_tools([...]).with_fallbacks([claude_3_sonnet.bind_tools([...])])
                llm.bind_tools([...])
                # -> RunnableWithFallbacks(
                    runnable=RunnableBinding(bound=ChatOpenAI(...), kwargs={"tools": [...]}),
                    fallbacks=[RunnableBinding(bound=ChatAnthropic(...), kwargs={"tools": [...]})],
                )

        )Úargsr=   r%   c                     s^   ˆ | i |¤Ž}g }ˆj D ]"}t|ˆƒ}| || i |¤Ž¡ qˆjf i i ˆ ¡ ¥||dœ¥¤ŽS )Nr:   )r"   ÚgetattrÚappendÚ	__class__Z
model_dump)r–   r=   Znew_runnableZnew_fallbacksÚfallbackZfallback_attr©ÚattrrD   r)   r*   r+   Úwrappedo  s    

ÿýÿz2RunnableWithFallbacks.__getattr__.<locals>.wrapped)r—   r!   Ú_returns_runnabler   r   )r)   rD   r�   r*   r›   r+   Ú__getattr__K  s    !z!RunnableWithFallbacks.__getattr__)N)N)N)N)N)N)N)N).Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r   r   Ú__annotations__r   Ú	Exceptionr#   ÚtuplerI   rR   r$   r   Ústrr   Zmodel_configÚpropertyr   r'   r,   r   r   r.   r0   Úlistr   r1   ÚclassmethodÚboolr8   r9   r   r;   r   rQ   r^   r	   r   rŽ   r�   r   r•   rŸ   r*   r*   r*   r+   r    %   s´   
5ÿ ÿþ ÿþ	 ÿ
þ1 ýû1 ýûù[ ýûùc ýû? ýû?r    )rœ   r%   c                 C   s,   t | ƒsdS t | ¡ d¡}t|o(t|ƒƒS )NFr%   )ÚcallableÚtypingÚget_type_hintsrL   r«   Ú_is_runnable_type)rœ   Úreturn_typer*   r*   r+   rž   „  s    rž   )Útype_r%   c                 C   sV   t  | ¡rt| tƒS t| dd ƒ}t  |¡r4t|tƒS |tju rRtdd„ | jD ƒƒS dS )NÚ
__origin__c                 s   s   | ]}t |ƒV  qd S r&   )r¯   )r2   Útr*   r*   r+   r5   ’  rq   z$_is_runnable_type.<locals>.<genexpr>F)	ÚinspectÚisclassÚ
issubclassr   r—   r­   r	   r{   Ú__args__)r±   Úoriginr*   r*   r+   r¯   ‹  s    




r¯   )/r£   r�   r´   r­   Úcollections.abcr   r   r   Ú	functoolsr   r   r   r   r	   r
   Zpydanticr   r   Ztyping_extensionsr   Z langchain_core.callbacks.managerr   r   Zlangchain_core.runnables.baser   r   Zlangchain_core.runnables.configr   r   r   r   r   r   r   Zlangchain_core.runnables.utilsr   r   r   r   r   Zlangchain_core.utils.aiterr   r   r    r«   rž   r¯   r*   r*   r*   r+   Ú<module>   s,   $	    c