
    ghne              	         U d Z ddlmZ ddlZddlZddlZddlmZ ddlm	Z	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mZmZ dd	lmZmZmZmZmZmZ dd
l m!Z!m"Z" ddl#m$Z$m%Z% ddl&m'Z' ddl(m)Z) e	rddlm*Z*m+Z+m,Z, ddl-m.Z.m/Z/ ddl0m1Z1 ddZ2ddZ3 G d deeef                   Z4 e4            Z5de6d<    G d dee7e8e
f         e7e8e
f         f                   Z9 G d dee7e8e
f         e7e8e
f         f                   Z:dS )z*Implementation of the RunnablePassthrough.    )annotationsN)	Awaitable)TYPE_CHECKINGAnyCallableOptionalUnioncast)	BaseModel	RootModel)override)OtherRunnableRunnableParallelRunnableSerializable)RunnableConfigacall_func_with_variable_argscall_func_with_variable_argsensure_configget_executor_for_configpatch_config)AddableDictConfigurableFieldSpec)ateepy_anext)safetee)create_model_v2)AsyncIteratorIteratorMapping)AsyncCallbackManagerForChainRunCallbackManagerForChainRun)Graphxr   returnc                    | S )zaIdentity function.

    Args:
        x (Other): input.

    Returns:
        Other: output.
     r$   s    a/var/www/FlaskApp/flask-venv/lib/python3.11/site-packages/langchain_core/runnables/passthrough.pyidentityr*   5   s	     H    c                
   K   | S )zgAsync identity function.

    Args:
        x (Other): input.

    Returns:
        Other: output.
    r'   r(   s    r)   	aidentityr-   A   s       Hr+   c                      e Zd ZU dZdZded<   dZded<   dZded<   ed'd            Z		 	 d(ddd) fdZ
eed*d                        Zeed+d                        Zeed'd                        Zeed'd                        Zeed,d                        Ze	 d-d.d            Ze	 d-d/d             Ze	 d-d0d"            Ze	 d-d1d$            Ze	 d-d2d%            Ze	 d-d3d&            Z xZS )4RunnablePassthrougha  Runnable to passthrough inputs unchanged or with additional keys.

    This Runnable behaves almost like the identity function, except that it
    can be configured to add additional keys to the output, if the input is a
    dict.

    The examples below demonstrate this Runnable works using a few simple
    chains. The chains rely on simple lambdas to make the examples easy to execute
    and experiment with.

    Examples:

        .. code-block:: python

            from langchain_core.runnables import (
                RunnableLambda,
                RunnableParallel,
                RunnablePassthrough,
            )

            runnable = RunnableParallel(
                origin=RunnablePassthrough(),
                modified=lambda x: x+1
            )

            runnable.invoke(1) # {'origin': 1, 'modified': 2}


            def fake_llm(prompt: str) -> str: # Fake LLM for the example
                return "completion"

            chain = RunnableLambda(fake_llm) | {
                'original': RunnablePassthrough(), # Original LLM output
                'parsed': lambda text: text[::-1] # Parsing logic
            }

            chain.invoke('hello') # {'original': 'completion', 'parsed': 'noitelpmoc'}

    In some cases, it may be useful to pass the input through while adding some
    keys to the output. In this case, you can use the `assign` method:

        .. code-block:: python

            from langchain_core.runnables import RunnablePassthrough

            def fake_llm(prompt: str) -> str: # Fake LLM for the example
                return "completion"

            runnable = {
                'llm1':  fake_llm,
                'llm2':  fake_llm,
            } | RunnablePassthrough.assign(
                total_chars=lambda inputs: len(inputs['llm1'] + inputs['llm2'])
            )

            runnable.invoke('hello')
            # {'llm1': 'completion', 'llm2': 'completion', 'total_chars': 20}
    NOptional[type[Other]]
input_typezQOptional[Union[Callable[[Other], None], Callable[[Other, RunnableConfig], None]]]funcgOptional[Union[Callable[[Other], Awaitable[None]], Callable[[Other, RunnableConfig], Awaitable[None]]]]afuncr%   r   c                    g S Nr'   selfs    r)   __repr_args__z!RunnablePassthrough.__repr_args__   s	     	r+   )r1   Optional[Union[Union[Callable[[Other], None], Callable[[Other, RunnableConfig], None]], Union[Callable[[Other], Awaitable[None]], Callable[[Other, RunnableConfig], Awaitable[None]]]]]kwargsNonec               r    t          j        |          r|}d} t                      j        d|||d| dS )zCreate e RunnablePassthrough.

        Args:
            func: Function to be called with the input.
            afunc: Async function to be called with the input.
            input_type: Type of the input.
        N)r2   r4   r1   r'   )inspectiscoroutinefunctionsuper__init__)r8   r2   r4   r1   r;   	__class__s        r)   rA   zRunnablePassthrough.__init__   sN    8 &t,, 	EDQd%JQQ&QQQQQr+   boolc                    dS NTr'   clss    r)   is_lc_serializablez&RunnablePassthrough.is_lc_serializable   	     tr+   	list[str]c                
    g dS N	langchainschemarunnabler'   rF   s    r)   get_lc_namespacez$RunnablePassthrough.get_lc_namespace        3222r+   c                    | j         pt          S r6   r1   r   r7   s    r)   	InputTypezRunnablePassthrough.InputType        %#%r+   c                    | j         pt          S r6   rT   r7   s    r)   
OutputTypezRunnablePassthrough.OutputType   rV   r+   Union[Runnable[dict[str, Any], Any], Callable[[dict[str, Any]], Any], Mapping[str, Union[Runnable[dict[str, Any], Any], Callable[[dict[str, Any]], Any]]]]RunnableAssignc                t    t          t          t          t          t          f                  |                    S )aK  Merge the Dict input with the output produced by the mapping argument.

        Args:
            **kwargs: Runnable, Callable or a Mapping from keys to Runnables
                or Callables.

        Returns:
            A Runnable that merges the Dict input with the output produced by the
            mapping argument.
        )rZ   r   dictstrr   )rG   r;   s     r)   assignzRunnablePassthrough.assign   s(    . .tCH~>vFFGGGr+   inputr   configOptional[RunnableConfig]c                    | j         !t          | j         |t          |          fi | |                     t          ||          S r6   )r2   r   r   _call_with_configr*   r8   r_   r`   r;   s       r)   invokezRunnablePassthrough.invoke   sV     9 (	5-"7"7 ;A   %%hv>>>r+   Optional[Any]c                   K   | j         (t          | j         |t          |          fi | d {V  n(| j        !t	          | j        |t          |          fi | |                     t          ||           d {V S r6   )r4   r   r   r2   r   _acall_with_configr-   rd   s       r)   ainvokezRunnablePassthrough.ainvoke   s       :!/
E=#8#8 <B          Y"(	5-"7"7 ;A   ,,YvFFFFFFFFFr+   Iterator[Other]c              +  4  K   | j         %|                     |t          |          D ]}|V  d S d}|                     |t          |          D ]%}|V  |s|}d}	 ||z   }# t          $ r |}Y "w xY w|r#t	          | j         |t          |          fi | d S d S NFT)r2   _transform_stream_with_configr*   	TypeErrorr   r   r8   r_   r`   r;   chunkgot_first_chunkfinals          r)   	transformzRunnablePassthrough.transform  s      9;;E8VTT    $O;;E8VTT 
& 
&& &!E&*OO& %$ & & & %&  ,IumF&;&; ?E     s   A!!A0/A0AsyncIterator[Other]c                 K   | j         3| j        ,|                     |t          |          2 3 d {V }|W V  6 d S d}|                     |t          |          2 3 d {V }|W V  |s|}d}	 ||z   }# t          $ r |}Y (w xY w6 |rOt          |          }| j         t          | j         ||fi | d {V  d S | j        t          | j        ||fi | d S d S d S rl   )r4   r2   _atransform_stream_with_configr*   rn   r   r   r   ro   s          r)   
atransformzRunnablePassthrough.atransform%  s      :$)"3#BBx          e      
 $O#BBx    & & & & & & &e  ' &!E&*OO& %$ & & & %&! &  U&v..:)7
E6 5;           Y*0E6TTVTTTTTU U +*s   :B/A55BBc                <     | j         t          |g          |fi |S r6   rs   iterrd   s       r)   streamzRunnablePassthrough.streamP  (     t~dE7mmV>>v>>>r+   c               b   K   dfd} | j          |            |fi |2 3 d {V }|W V  6 d S )Nr%   rt   c                   K    W V  d S r6   r'   r_   s   r)   input_aiterz0RunnablePassthrough.astream.<locals>.input_aiter`        KKKKKKr+   )r%   rt   rw   r8   r_   r`   r;   r   rp   s    `    r)   astreamzRunnablePassthrough.astreamY        	 	 	 	 	 	 +4?;;==&KKFKK 	 	 	 	 	 	 	%KKKKK LKK   .)r%   r   )NN)
r2   r:   r4   r3   r1   r0   r;   r   r%   r<   r%   rC   r%   rJ   )r;   rY   r%   rZ   r6   )r_   r   r`   ra   r;   r   r%   r   )r_   r   r`   ra   r;   rf   r%   r   )r_   rj   r`   ra   r;   r   r%   rj   )r_   rt   r`   ra   r;   r   r%   rt   )r_   r   r`   ra   r;   r   r%   rj   )r_   r   r`   ra   r;   r   r%   rt   )__name__
__module____qualname____doc__r1   __annotations__r2   r4   r   r9   rA   classmethodrH   rQ   propertyrU   rX   r^   re   ri   rs   rw   r{   r   __classcell__rB   s   @r)   r/   r/   M   s        9 9v )-J,,,, 	 	     	 
        X  ! R$ -1% R  R  R  R  R  R  R  RD    X [ 3 3 3 X [3 & & & X X& & & & X X& H H H X [H. ?C? ? ? ? X?  ,0G G G G XG   ,0    X<  ,0(U (U (U (U X(UT  ,0? ? ? ? X?  ,0
 
 
 
 X
 
 
 
 
r+   r/   _graph_passthroughc                      e Zd ZU dZded<   d2 fd	Zeed3d                        Zeed4d                        Z	e	 d5ddd6 fd            Z
e	 d5d7 fd            Ze	 d5d7 fd            Zeed8d                        Zed5d9d            Zd:d$Ze	 d5d;d%            Zd<d'Ze	 d5d;d(            Zd=d*Ze	 d5d>d,            Zd?d.Ze	 d5d@d/            Ze	 d5dAd0            Ze	 d5dBd1            Z xZS )CrZ   a  Runnable that assigns key-value pairs to dict[str, Any] inputs.

    The `RunnableAssign` class takes input dictionaries and, through a
    `RunnableParallel` instance, applies transformations, then combines
    these with the original data, introducing new key-value pairs based
    on the mapper's logic.

    Examples:
        .. code-block:: python

            # This is a RunnableAssign
            from langchain_core.runnables.passthrough import (
                RunnableAssign,
                RunnableParallel,
            )
            from langchain_core.runnables.base import RunnableLambda

            def add_ten(x: dict[str, int]) -> dict[str, int]:
                return {"added": x["input"] + 10}

            mapper = RunnableParallel(
                {"add_step": RunnableLambda(add_ten),}
            )

            runnable_assign = RunnableAssign(mapper)

            # Synchronous example
            runnable_assign.invoke({"input": 5})
            # returns {'input': 5, 'add_step': {'added': 15}}

            # Asynchronous example
            await runnable_assign.ainvoke({"input": 5})
            # returns {'input': 5, 'add_step': {'added': 15}}
    r   mapper RunnableParallel[dict[str, Any]]r;   r   r%   r<   c                >     t                      j        dd|i| dS )zCreate a RunnableAssign.

        Args:
            mapper: A ``RunnableParallel`` instance that will be used to transform the
                input dictionary.
        r   Nr'   r@   rA   )r8   r   r;   rB   s      r)   rA   zRunnableAssign.__init__  s-     	111&11111r+   rC   c                    dS rE   r'   rF   s    r)   rH   z!RunnableAssign.is_lc_serializable  rI   r+   rJ   c                
    g dS rL   r'   rF   s    r)   rQ   zRunnableAssign.get_lc_namespace  rR   r+   NnamesuffixOptional[str]r   r]   c                   |p;| j         p4dd                    | j        j                                                   d}t                                          ||          S )NzRunnableAssign<,>r   )r   joinr   steps__keysr@   get_namer8   r   r   rB   s      r)   r   zRunnableAssign.get_name  sh    
  IyIH$+*=*B*B*D*D!E!EHHH 	
 wwT222r+   r`   ra   type[BaseModel]c                    | j                             |          }t          |t                    s|S t	                                          |          S r6   )r   get_input_schema
issubclassr   r@   )r8   r`   map_input_schemarB   s      r)   r   zRunnableAssign.get_input_schema  sL      ;77??*I66 	$##ww''///r+   c                   | j                             |          }| j                             |          }t          |t                    st          |t                    ssi }|j                                        D ]\  }}|j        |j        f||<   |j                                        D ]\  }}|j        |j        f||<   t          d|          S t          |t                    s|S t                                          |          S )NRunnableAssignOutput)field_definitions)r   r   get_output_schemar   r   model_fieldsitems
annotationdefaultr   r@   )r8   r`   r   map_output_schemafieldsr   
field_inforB   s          r)   r   z RunnableAssign.get_output_schema  s"     ;77?? K99&AA*I66 	Uzy@
 @
 	U F$4$A$G$G$I$I K K j * 5z7IJt$5$B$H$H$J$J K K j * 5z7IJt"#9VTTTT+Y77 	% %$ww((000r+   list[ConfigurableFieldSpec]c                    | j         j        S r6   )r   config_specsr7   s    r)   r   zRunnableAssign.config_specs  s     {''r+   RunnableConfig | Noner#   c                   | j                             |          }|                                }|                                }|H|F|                    t
                    }|                    ||           |                    ||           |S r6   )r   	get_graph
first_node	last_nodeadd_noder   add_edge)r8   r`   graph
input_nodeoutput_nodepassthrough_nodes         r)   r   zRunnableAssign.get_graph  s     %%f--%%''
oo''!k&=$~~.@AANN:'7888NN+[999r+   r_   dict[str, Any]run_managerr"   r   c           	         t          |t                    sd}t          |          i | | j        j        |t          ||                                          fi |S N9The input to RunnablePassthrough.assign() must be a dict.	callbacks)
isinstancer\   
ValueErrorr   re   r   	get_childr8   r_   r   r`   r;   msgs         r)   _invokezRunnableAssign._invoke  s     %&& 	"MCS//!

 dk V{/D/D/F/FGGG   
 	
r+   c                ,     | j         | j        ||fi |S r6   rc   r   rd   s       r)   re   zRunnableAssign.invoke  %     &t%dlE6LLVLLLr+   r!   c           	        K   t          |t                    sd}t          |          i | | j        j        |t          ||                                          fi | d {V S r   )r   r\   r   r   ri   r   r   r   s         r)   _ainvokezRunnableAssign._ainvoke  s       %&& 	"MCS//!

'DK'V{/D/D/F/FGGG         
 	
r+   c                <   K    | j         | j        ||fi | d {V S r6   rh   r   rd   s       r)   ri   zRunnableAssign.ainvoke  ;       -T,T]E6TTVTTTTTTTTTr+   Iterator[dict[str, Any]]c              +    K   t          | j        j                                                  t	          |dt          j                              \  }} | j        j        |t          ||	                                          fi |}t          |          5 }|                    t          |d           }	|D ][}
t          |
t                    sd}t          |          t!          fd|
                                D                       }|r|V  \t%          d|	                                          V  |D ]}
|
V  	 d d d            d S # 1 swxY w Y   d S )N   lockr   r   c                $    i | ]\  }}|v	||S r'   r'   .0kvmapper_keyss      r)   
<dictcomp>z-RunnableAssign._transform.<locals>.<dictcomp>C  s)    LLLdaq7K7KQ7K7K7Kr+   r   )setr   r   r   r   	threadingLockrs   r   r   r   submitnextr   r\   r   r   r   r
   result)r8   r_   r   r`   r;   for_passthroughfor_map
map_outputexecutorfirst_map_chunk_futurerp   r   filteredr   s                @r)   
_transformzRunnableAssign._transform  s      $+-224455#*5!).:J:J#K#K#K  +T[*%//11  
 
 
 

 %V,, 	%-__& &" ) 	# 	#!%.. *UC$S//)&LLLLekkmmLLL   #"NNN')?)F)F)H)HIIIII#  )	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	s   B(EEE
Any | Nonec              +  @   K    | j         || j        |fi |E d {V  d S r6   rm   r   rd   s       r)   rs   zRunnableAssign.transformL  ]       6454?F
 
.4
 
 	
 	
 	
 	
 	
 	
 	
 	
 	
r+   AsyncIterator[dict[str, Any]]c               \  K   t          | j        j                                                  t	          |dt          j                              \  }} | j        j        |t          ||	                                          fi |}t          j
        t          |d                     }|2 3 d {V }	t          |	t                    sd}
t          |
          t          fd|	                                D                       }|r|W V  b6 | d {V W V  |2 3 d {V }	|	W V  6 d S )Nr   r   r   r   c                $    i | ]\  }}|v	||S r'   r'   r   s      r)   r   z.RunnableAssign._atransform.<locals>.<dictcomp>w  s)    HHH$!Q1K3G3GA3G3G3Gr+   )r   r   r   r   r   asyncior   rw   r   r   create_taskr   r   r\   r   r   r   )r8   r_   r   r`   r;   r   r   r   first_map_chunk_taskrp   r   r   r   s               @r)   _atransformzRunnableAssign._atransformW  s      $+-224455#'qw|~~#F#F#F +T[+%//11  
 
 
 

 .5-@Z&&.
 .
 + 
	 
	 
	 
	 
	 
	 
	%eT** &Q oo% #HHHH%++--HHH H   + )((((((((((% 	 	 	 	 	 	 	%KKKKK &::s   .DD+c               P   K    | j         || j        |fi |2 3 d {V }|W V  6 d S r6   rv   r   r8   r_   r`   r;   rp   s        r)   rw   zRunnableAssign.atransform  t       ?4>4#V
 
/5
 
 	 	 	 	 	 	 	% KKKKK
 
 
   %c                <     | j         t          |g          |fi |S r6   ry   rd   s       r)   r{   zRunnableAssign.stream  r|   r+   c               b   K   dfd} | j          |            |fi |2 3 d {V }|W V  6 d S )Nr%   r   c                   K    W V  d S r6   r'   r   s   r)   r   z+RunnableAssign.astream.<locals>.input_aiter  r   r+   r%   r   r   r   s    `    r)   r   zRunnableAssign.astream  r   r   )r   r   r;   r   r%   r<   r   r   r6   r   r   r   r   r%   r]   )r`   ra   r%   r   )r%   r   )r`   r   r%   r#   )
r_   r   r   r"   r`   r   r;   r   r%   r   r_   r   r`   ra   r;   r   r%   r   )
r_   r   r   r!   r`   r   r;   r   r%   r   )
r_   r   r   r"   r`   r   r;   r   r%   r   )r_   r   r`   ra   r;   r   r%   r   )
r_   r   r   r!   r`   r   r;   r   r%   r   r_   r   r`   ra   r;   r   r%   r   r_   r   r`   ra   r;   r   r%   r   r_   r   r`   ra   r;   r   r%   r   )r   r   r   r   r   rA   r   r   rH   rQ   r   r   r   r   r   r   r   re   r   ri   r   rs   r   rw   r{   r   r   r   s   @r)   rZ   rZ   j  s        ! !F 2 2 2 2 2 2    X [ 3 3 3 X [3 &*3EI3 3 3 3 3 3 3 X3 150 0 0 0 0 0 X0 151 1 1 1 1 1 X10 ( ( ( X X( 
 
 
 
 X

 
 
 
(  ,0M M M M XM
 
 
 
(  ,0U U U U XU, , , ,\  ,0
 
 
 
 X
' ' ' 'R  ,0	 	 	 	 X	  ,0? ? ? ? X?  ,0
 
 
 
 X
 
 
 
 
r+   rZ   c                  v    e Zd ZU dZded<   d% fdZeed&d
                        Zeed'd                        Z	e	 d(ddd) fd            Z
d*dZd+dZe	 d(d,d            Zd+dZe	 d(d,d            Zd-dZe	 d(d.d            Zd/d!Ze	 d(d0d"            Ze	 d(d1d#            Ze	 d(d2d$            Z xZS )3RunnablePicka  Runnable that picks keys from dict[str, Any] inputs.

    RunnablePick class represents a Runnable that selectively picks keys from a
    dictionary input. It allows you to specify one or more keys to extract
    from the input dictionary. It returns a new dictionary containing only
    the selected keys.

    Example:
        .. code-block:: python

            from langchain_core.runnables.passthrough import RunnablePick

            input_data = {
                'name': 'John',
                'age': 30,
                'city': 'New York',
                'country': 'USA'
            }

            runnable = RunnablePick(keys=['name', 'age'])

            output_data = runnable.invoke(input_data)

            print(output_data)  # Output: {'name': 'John', 'age': 30}
    Union[str, list[str]]r   r;   r   r%   r<   c                >     t                      j        dd|i| dS )zCreate a RunnablePick.

        Args:
            keys: A single key or a list of keys to pick from the input dictionary.
        r   Nr'   r   )r8   r   r;   rB   s      r)   rA   zRunnablePick.__init__  s-     	--d-f-----r+   rC   c                    dS rE   r'   rF   s    r)   rH   zRunnablePick.is_lc_serializable  rI   r+   rJ   c                
    g dS )z*Get the namespace of the langchain object.rM   r'   rF   s    r)   rQ   zRunnablePick.get_lc_namespace  s     3222r+   Nr   r   r   r   r]   c                   |pF| j         p?dd                    t          | j        t                    r| j        gn| j                   d}t                                          ||          S )NzRunnablePick<r   r   r   )r   r   r   r   r]   r@   r   r   s      r)   r   zRunnablePick.get_name  st    
  eyedsxxz$)S7Q7Q(`W[W`aaddd 	
 wwT222r+   r_   r   c                   t          t                    sd}t          |          t          | j        t                    r                    | j                  S fd| j        D             }|rt          |          S d S )Nr   c                D    i | ]}|v |                     |          S r'   )get)r   r   r_   s     r)   r   z&RunnablePick._pick.<locals>.<dictcomp>  s*    CCCaU

!UYYq\\


r+   )r   r\   r   r   r]   r  r   )r8   r_   r   pickeds    `  r)   _pickzRunnablePick._pick  s    %&& 	"MCS//!di%% 	(99TY'''CCCC49CCC 	'v&&&tr+   c                ,    |                      |          S r6   r  r8   r_   s     r)   r   zRunnablePick._invoke  s     zz%   r+   r`   ra   c                ,     | j         | j        ||fi |S r6   r   rd   s       r)   re   zRunnablePick.invoke  r   r+   c                0   K   |                      |          S r6   r  r  s     r)   r   zRunnablePick._ainvoke  s       zz%   r+   c                <   K    | j         | j        ||fi | d {V S r6   r   rd   s       r)   ri   zRunnablePick.ainvoke  r   r+   r   c              #  J   K   |D ]}|                      |          }||V  d S r6   r  r8   r_   rp   r  s       r)   r   zRunnablePick._transform  sB        	 	EZZ&&F!	 	r+   c              +  @   K    | j         || j        |fi |E d {V  d S r6   r   rd   s       r)   rs   zRunnablePick.transform  r   r+   r   c               X   K   |2 3 d {V }|                      |          }||W V  $6 d S r6   r  r  s       r)   r   zRunnablePick._atransform  s\       ! 	 	 	 	 	 	 	%ZZ&&F! !55s   )c               P   K    | j         || j        |fi |2 3 d {V }|W V  6 d S r6   r   r   s        r)   rw   zRunnablePick.atransform%  r   r  c                <     | j         t          |g          |fi |S r6   ry   rd   s       r)   r{   zRunnablePick.stream1  r|   r+   c               b   K   dfd} | j          |            |fi |2 3 d {V }|W V  6 d S )Nr%   r   c                   K    W V  d S r6   r'   r   s   r)   r   z)RunnablePick.astream.<locals>.input_aiterA  r   r+   r  r   r   s    `    r)   r   zRunnablePick.astream:  r   r   )r   r  r;   r   r%   r<   r   r   r6   r  )r_   r   r%   r   )r_   r   r%   r   r  )r_   r   r%   r   )r_   r   r`   ra   r;   r   r%   r   )r_   r   r%   r   r  r	  r
  )r   r   r   r   r   rA   r   r   rH   rQ   r   r  r   re   r   ri   r   rs   r   rw   r{   r   r   r   s   @r)   r  r    sT         4  . . . . . .    X [ 3 3 3 X [3 &*3EI3 3 3 3 3 3 3 X3
 
 
 
! ! ! !  ,0M M M M XM! ! ! !  ,0U U U U XU     ,0
 
 
 
 X
     ,0	 	 	 	 X	  ,0? ? ? ? X?  ,0
 
 
 
 X
 
 
 
 
r+   r  )r$   r   r%   r   );r   
__future__r   r   r>   r   collections.abcr   typingr   r   r   r   r	   r
   pydanticr   r   typing_extensionsr   langchain_core.runnables.baser   r   r   r   langchain_core.runnables.configr   r   r   r   r   r   langchain_core.runnables.utilsr   r   langchain_core.utils.aiterr   r   langchain_core.utils.iterr   langchain_core.utils.pydanticr   r   r   r     langchain_core.callbacks.managerr!   r"   langchain_core.runnables.graphr#   r*   r-   r/   r   r   r\   r]   rZ   r  r'   r+   r)   <module>r2     sI   0 0 0 " " " " " "       % % % % % %                * ) ) ) ) ) ) ) & & & & & &                                  6 5 5 5 5 5 5 5 - - - - - - 9 9 9 9 9 9 5@@@@@@@@@@        544444	 	 	 		 	 	 	W W W W W.ue|< W W Wt +>*=*?*?  ? ? ? ?v v v v v)$sCx.$sCx.*HI v v vr	b b b b b'S#XS#X(FG b b b b br+   