
    g3fiqe              	         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mZ ddl	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" 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l-m.Z. ddZ/ddZ0 G d deeef         Z1 e1       Z2de3d<    G d dee4e5ef   e4e5ef   f         Z6 G d dee4e5ef   ef         Z7y)z*Implementation of the RunnablePassthrough.    )annotationsN)	AwaitableCallable)TYPE_CHECKINGAny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)safetee)create_model_v2)AsyncIteratorIteratorMapping)AsyncCallbackManagerForChainRunCallbackManagerForChainRun)Graphc                    | S )zRIdentity function.

    Args:
        x: Input.

    Returns:
        Output.
     xs    b/var/www/auto_recruiter/arenv/lib/python3.12/site-packages/langchain_core/runnables/passthrough.pyidentityr&   2   s	     H    c                   K   | S w)zXAsync identity function.

    Args:
        x: Input.

    Returns:
        Output.
    r"   r#   s    r%   	aidentityr)   >   s      Hs   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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	 	 	 	 	 	 	 d d       Ze	 d	 	 	 	 	 	 	 d!d       Ze	 d	 	 	 	 	 	 	 d"d       Ze	 d	 	 	 	 	 	 	 d#d       Z xZS )$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:
        ```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:

        ```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type[Other] | None
input_typezHCallable[[Other], None] | Callable[[Other, RunnableConfig], None] | Nonefunc^Callable[[Other], Awaitable[None]] | Callable[[Other, RunnableConfig], Awaitable[None]] | Noneafuncc                    g S Nr"   selfs    r%   __repr_args__z!RunnablePassthrough.__repr_args__   s	     	r'   )r-   c               ^    t        j                  |      r|}d}t        |   d|||d| y)zCreate a `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)r.   r0   r-   r"   )inspectiscoroutinefunctionsuper__init__)r4   r.   r0   r-   kwargs	__class__s        r%   r:   zRunnablePassthrough.__init__   s6    * &&t,EDQd%JQ&Qr'   c                     yz,Return `True` as this class is serializable.Tr"   clss    r%   is_lc_serializablez&RunnablePassthrough.is_lc_serializable        r'   c                
    g dS zwGet the namespace of the LangChain object.

        Returns:
            `["langchain", "schema", "runnable"]`
        )	langchainschemarunnabler"   r?   s    r%   get_lc_namespacez$RunnablePassthrough.get_lc_namespace   s
     32r'   c                *    | j                   xs t        S r2   r-   r   r3   s    r%   	InputTypezRunnablePassthrough.InputType        %#%r'   c                *    | j                   xs t        S r2   rJ   r3   s    r%   
OutputTypezRunnablePassthrough.OutputType   rL   r'   c                R    t        t        t        t        t        f      |            S )a`  Merge the Dict input with the output produced by the mapping argument.

        Args:
            **kwargs: `Runnable`, `Callable` or a `Mapping` from keys to `Runnable`
                objects or `Callable`s.

        Returns:
            A `Runnable` that merges the `dict` input with the output produced by the
            mapping argument.
        )RunnableAssignr   dictstrr   )r@   r;   s     r%   assignzRunnablePassthrough.assign   s"    $ .tCH~>vFGGr'   c                    | j                   !t        | j                   |t        |      fi | | j                  t        ||      S r2   )r.   r   r   _call_with_configr&   r4   inputconfigr;   s       r%   invokezRunnablePassthrough.invoke   sE     99 (		5-"7;A %%hv>>r'   c                  K   | j                   *t        | j                   |t        |      fi | d {    n-| j                  !t	        | j                  |t        |      fi | | j                  t        ||       d {   S 7 Q7 wr2   )r0   r   r   r.   r   _acall_with_configr)   rV   s       r%   ainvokezRunnablePassthrough.ainvoke   s      ::!/

E=#8<B   YY"(		5-"7;A ,,YvFFF Gs"   1B	BAB	 BB	B	c              +  .  K   | j                   !| j                  |t        |      D ]  }|  y d}| j                  |t        |      D ]  }| |s|}d}	 |z   } |r"t	        | j                   t        |      fi | y y # t        $ r |}Y Hw xY wwNFT)r.   _transform_stream_with_configr&   	TypeErrorr   r   r4   rW   rX   r;   chunkgot_first_chunkfinals          r%   	transformzRunnablePassthrough.transform   s      99;;E8VT  $O;;E8VT 
&&!E&*O& %
& ,IIumF&;?E  % & %&s*   ABB'BBBBBc                 K   | j                   2| j                  &| j                  |t        |      2 3 d {   }| d}| j                  |t        |      2 3 d {   }| |s|}d}	 |z   }7 ?6 y 7 # t        $ r |}Y /w xY w6 |r_t        |      }| j                   "t        | j                   |fi | d {  7   y | j                  t        | j                  |fi | y y y wr^   )r0   r.   _atransform_stream_with_configr&   r`   r   r   r   ra   s          r%   
atransformzRunnablePassthrough.atransform  s!     ::$))"3#BBx   e #O#BBx  & &e  '!E&*O& %-  &  % & %&! & &v.::)7

E65;   YY*0E6TVT + ss   0C0A8A6A8 C0BA:B"C00A<5C06A88C0:B<B
C0	B

8C0C-C0c                >     | j                   t        |g      |fi |S r2   re   iterrV   s       r%   streamzRunnablePassthrough.streamF  "     t~~dE7mV>v>>r'   c               p   K   dfd} | j                    |       |fi |2 3 d {   }| 7 
6 y w)Nc                   K     y wr2   r"   rW   s   r%   input_aiterz0RunnablePassthrough.astream.<locals>.input_aiterV       K   
)returnAsyncIterator[Other]rh   r4   rW   rX   r;   rq   rb   s    `    r%   astreamzRunnablePassthrough.astreamO  ?     	 +4??;=&KFK 	 	%K	K    6424646)rt   r   )NN)
r.   zCallable[[Other], None] | Callable[[Other, RunnableConfig], None] | Callable[[Other], Awaitable[None]] | Callable[[Other, RunnableConfig], Awaitable[None]] | Noner0   r/   r-   r,   r;   r   rt   Nonert   boolrt   z	list[str])r;   zRunnable[dict[str, Any], Any] | Callable[[dict[str, Any]], Any] | Mapping[str, Runnable[dict[str, Any], Any] | Callable[[dict[str, Any]], Any]]rt   rP   r2   )rW   r   rX   RunnableConfig | Noner;   r   rt   r   )rW   r   rX   r   r;   
Any | Nonert   r   )rW   Iterator[Other]rX   r   r;   r   rt   r   )rW   ru   rX   r   r;   r   rt   ru   )rW   r   rX   r   r;   r   rt   r   )rW   r   rX   r   r;   r   rt   ru   )__name__
__module____qualname____doc__r-   __annotations__r.   r0   r   r5   r:   classmethodrA   rH   propertyrK   rN   rS   rY   r\   re   rh   rl   rx   __classcell__r<   s   @r%   r+   r+   J   s   :x &*J") 	 	
R  		 
	    R *.RRR 'R R 
R6    3 3 &  & &  & HXH
 
H  H$ <@??$9?LO?	? ?  )-GG &G 	G
 
G G   )- & 	
 
 <  )-(U#(U &(U 	(U
 
(U (UT  )-?? &? 	?
 
? ?  )-

 &
 	

 

 
r'   r+   _graph_passthroughc                  6    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
edd fd
       Ze	 d	 	 	 d fd       Zee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	 	 	 	 	 	 	 d$d       Z	 	 	 	 	 	 	 	 	 	 d%dZe	 d	 	 	 	 	 	 	 d&d       Ze	 d	 	 	 	 	 	 	 d'd       Ze	 d	 	 	 	 	 	 	 d(d       Z xZS ))rP   ay  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:
        ```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   mapperc                (    t        |   dd|i| y)zCreate a `RunnableAssign`.

        Args:
            mapper: A `RunnableParallel` instance that will be used to transform the
                input dictionary.
        r   Nr"   r9   r:   )r4   r   r;   r<   s      r%   r:   zRunnableAssign.__init__  s     	11&1r'   c                     yr>   r"   r?   s    r%   rA   z!RunnableAssign.is_lc_serializable  rB   r'   c                
    g dS rD   r"   r?   s    r%   rH   zRunnableAssign.get_lc_namespace  
     32r'   Nnamec                   |xsE | j                   xs7 ddj                  | j                  j                  j	                                d}t
        |   ||      S )NzRunnableAssign<,>r   )r   joinr   steps__keysr9   get_namer4   suffixr   r<   s      r%   r   zRunnableAssign.get_name  s`      IyyI $++*=*=*B*B*D!E FaH 	
 wT22r'   c                |    | j                   j                  |      }t        |t              s|S t        |   |      S r2   )r   get_input_schema
issubclassr
   r9   )r4   rX   map_input_schemar<   s      r%   r   zRunnableAssign.get_input_schema  s9    ;;77?*I6##w'//r'   c                   | j                   j                  |      }| j                   j                  |      }t        |t              st        |t              si }|j
                  j                         D ]   \  }}|j                  |j                  f||<   " |j
                  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   r9   )r4   rX   r   map_output_schemafieldsr   
field_infor<   s          r%   r   z RunnableAssign.get_output_schema  s     ;;77? KK99&A*I6zy@
 F$4$A$A$G$G$I K j * 5 5z7I7IJtK %6$B$B$H$H$J K j * 5 5z7I7IJtK ##9VTT+Y7 %$w(00r'   c                .    | j                   j                  S r2   )r   config_specsr3   s    r%   r   zRunnableAssign.config_specs  s     {{'''r'   c                    | j                   j                  |      }|j                         }|j                         }|;|9|j	                  t
              }|j                  ||       |j                  ||       |S r2   )r   	get_graph
first_node	last_nodeadd_noder   add_edge)r4   rX   graph
input_nodeoutput_nodepassthrough_nodes         r%   r   zRunnableAssign.get_graph  sp     %%f-%%'
oo'!k&=$~~.@ANN:'78NN+[9r'   c           	         t        |t              sd}t        |      i | | j                  j                  |t        ||j                               fi |S N9The input to RunnablePassthrough.assign() must be a dict.	callbacks)
isinstancerQ   
ValueErrorr   rY   r   	get_childr4   valuerun_managerrX   r;   msgs         r%   _invokezRunnableAssign._invoke  sh     %&MCS/!

 dkk  V{/D/D/FG 
 	
r'   c                @     | j                   | j                  ||fi |S r2   )rU   r   rV   s       r%   rY   zRunnableAssign.invoke  s$     &t%%dllE6LVLLr'   c           	        K   t        |t              sd}t        |      i | | j                  j                  |t        ||j                               fi | d {   S 7 wr   )r   rQ   r   r   r\   r   r   r   s         r%   _ainvokezRunnableAssign._ainvoke  sv      %&MCS/!

'DKK''V{/D/D/FG  
 	
s   AA%A#A%c                \   K    | j                   | j                  ||fi | d {   S 7 wr2   r[   r   rV   s       r%   r\   zRunnableAssign.ainvoke  .      -T,,T]]E6TVTTTT   #,*,c           
   +    K   t        | j                  j                  j                               }t	        |dt        j                               \  }} | j                  j                  |t        ||j                               fi |}t        |      5 }	|	j                  t        |d       }
|D ]X  }t        |t              sd}t        |      t!        |j#                         D ci c]  \  }}||vs|| c}}      }|sU| Z t%        d|
j'                                |D ]  }|  	 d d d        y c c}}w # 1 sw Y   y xY ww)N   lockr   r   dict[str, Any])setr   r   r   r   	threadingLockre   r   r   r   submitnextr   rQ   r   r   r   r   result)r4   valuesr   rX   r;   mapper_keysfor_passthroughfor_map
map_outputexecutorfirst_map_chunk_futurerb   r   kvfiltereds                   r%   
_transformzRunnableAssign._transform  sM     $++--2245#*619>>;K#L  +T[[**%//1
 

 %V, 	%-__&" ) 	#!%.UC$S/)&&+kkmLdaq7KQTL "N	# ')?)F)F)HII# )	 	 M	 	s=   BEAE'D;4D;9
E-E2	E;EE
Ec              +  ^   K    | j                   || j                  |fi |E d {    y 7 wr2   r_   r   rV   s       r%   re   zRunnableAssign.transformH  5      64554??F
.4
 	
 	
   #-+-c           	    r  K   t        | j                  j                  j                               }t	        |dt        j                               \  }} | j                  j                  |t        ||j                               fi |}t        j                  t        |d             }	|2 3 d {   }
t        |
t              sd}t        |      t        |
j!                         D ci c]  \  }}||vs|| c}}      }|s[| a7 \c c}}w 6 |	 d {  7   |2 3 d {  7  }
|
 6 y w)Nr   r   r   r   )r   r   r   r   r   asyncior   rh   r   r   create_taskanextr   rQ   r   r   r   )r4   r   r   rX   r;   r   r   r   r   first_map_chunk_taskrb   r   r   r   r   s                  r%   _atransformzRunnableAssign._atransformS  s/     $++--2245#'#G +T[[++%//1
 

 .5-@-@*d#.
 + 
	 
	%eT*Q o% #"'++-H$!Q1K3GAHH 
	 I + )(((% 	 	%K &sf   B)D7+D/D0D36D7)D6D;
D7D7DD7D
D7%D5)D,*D5.	D7c               n   K    | j                   || j                  |fi |2 3 d {   }| 7 
6 y wr2   rg   r   r4   rW   rX   r;   rb   s        r%   rh   zRunnableAssign.atransform|  K      ?4>>4##V
/5
 	 	% K	 
    5313535c                >     | j                   t        |g      |fi |S r2   rj   rV   s       r%   rl   zRunnableAssign.stream  rm   r'   c               p   K   dfd} | j                    |       |fi |2 3 d {   }| 7 
6 y w)Nc                   K     y wr2   r"   rp   s   r%   rq   z+RunnableAssign.astream.<locals>.input_aiter  rr   rs   rt   AsyncIterator[dict[str, Any]]rv   rw   s    `    r%   rx   zRunnableAssign.astream  ry   rz   )r   z RunnableParallel[dict[str, Any]]r;   r   rt   r{   r|   r~   r2   r   
str | Noner   r   rt   rR   )rX   r   rt   ztype[BaseModel])rt   zlist[ConfigurableFieldSpec])rX   r   rt   r    )
r   r   r   r   rX   r   r;   r   rt   r   )rW   r   rX   r   r;   r   rt   r   )
r   r   r   r   rX   r   r;   r   rt   r   )
r   Iterator[dict[str, Any]]r   r   rX   r   r;   r   rt   r   )rW   r   rX   r   r;   r   rt   r   )
r   r   r   r   rX   r   r;   r   rt   r   )rW   r   rX   r   r;   r   rt   r   )rW   r   rX   r   r;   r   rt   r   )rW   r   rX   r   r;   r   rt   r   )r   r   r   r   r   r:   r   r   rA   rH   r   r   r   r   r   r   r   rY   r   r\   r   re   r   rh   rl   rx   r   r   s   @r%   rP   rP   `  s0   %N 2    3  3 3 3 3 0 0 .21+1	1 10 (  ( 
 


 0
 	

 
 

(  )-MM &M 	M
 
M M

 5
 	

 
 

(  )-UU &U 	U
 
U U,(, 0, 	,
 , 
",\  )-
'
 &
 	

 
"
 
'-' 5' 	'
 ' 
''R  )-	,	 &	 		
 
'	 	  )-?? &? 	?
 
"? ?  )-

 &
 	

 
'
 
r'   rP   c                      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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	 	 	 	 	 	 	 dd       Ze	 d	 	 	 	 	 	 	 dd       Ze	 d	 	 	 	 	 	 	 d d       Z xZS )!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.

    !!! note "Return Type Behavior"
        The return type depends on the `keys` parameter:

        - When `keys` is a `str`: Returns the single value associated with that key
        - When `keys` is a `list`: Returns a dictionary containing only the selected
            keys

    Example:
        ```python
        from langchain_core.runnables.passthrough import RunnablePick

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

        # Single key - returns the value directly
        runnable_single = RunnablePick(keys="name")
        result_single = runnable_single.invoke(input_data)
        print(result_single)  # Output: "John"

        # Multiple keys - returns a dictionary
        runnable_multiple = RunnablePick(keys=["name", "age"])
        result_multiple = runnable_multiple.invoke(input_data)
        print(result_multiple)  # Output: {'name': 'John', 'age': 30}
        ```
    str | list[str]r   c                (    t        |   dd|i| y)zCreate a `RunnablePick`.

        Args:
            keys: A single key or a list of keys to pick from the input dictionary.
        r   Nr"   r   )r4   r   r;   r<   s      r%   r:   zRunnablePick.__init__  s     	-d-f-r'   c                     yr>   r"   r?   s    r%   rA   zRunnablePick.is_lc_serializable  rB   r'   c                
    g dS rD   r"   r?   s    r%   rH   zRunnablePick.get_lc_namespace  r   r'   Nr   c                   |xsT | j                   xsF ddj                  t        | j                  t              r| j                  gn| j                         d}t
        |   ||      S )NzRunnablePick<r   r   r   )r   r   r   r   rR   r9   r   r   s      r%   r   zRunnablePick.get_name  sm      VyyV
499c(B$))		RSSTV 	 wT22r'   c                (   t        |t              sd}t        |      t        | j                  t              r|j                  | j                        S | j                  D ci c]  }||v s||j                  |       }}|rt        |      S y c c}w )Nr   )r   rQ   r   r   rR   getr   )r4   r   r   r   pickeds        r%   _pickzRunnablePick._pick  s|    %&MCS/!dii%99TYY''+/99CaU
!UYYq\/CCv&& Ds   !	B+Bc                @     | j                   | j                  ||fi |S r2   )rU   r  rV   s       r%   rY   zRunnablePick.invoke  s$     &t%%djj%J6JJr'   c                ,   K   | j                  |      S wr2   r  )r4   r   s     r%   r   zRunnablePick._ainvoke  s      zz%  s   c                \   K    | j                   | j                  ||fi | d {   S 7 wr2   r   rV   s       r%   r\   zRunnablePick.ainvoke  r   r   c              #  J   K   |D ]  }| j                  |      }||  y wr2   r  r4   chunksrb   r  s       r%   r   zRunnablePick._transform  s0       	EZZ&F!	s   ##c              +  ^   K    | j                   || j                  |fi |E d {    y 7 wr2   r   rV   s       r%   re   zRunnablePick.transform  r   r   c               \   K   |2 3 d {   }| j                  |      }|| #7 6 y wr2   r  r
  s       r%   r   zRunnablePick._atransform   s8      " 	 	%ZZ&F!	6s    ,*(*,,*,c               n   K    | j                   || j                  |fi |2 3 d {   }| 7 
6 y wr2   r   r   s        r%   rh   zRunnablePick.atransform)  r   r   c                >     | j                   t        |g      |fi |S r2   rj   rV   s       r%   rl   zRunnablePick.stream5  rm   r'   c               p   K   dfd} | j                    |       |fi |2 3 d {   }| 7 
6 y w)Nc                   K     y wr2   r"   rp   s   r%   rq   z)RunnablePick.astream.<locals>.input_aiterE  rr   rs   r   rv   rw   s    `    r%   rx   zRunnablePick.astream>  ry   rz   )r   r   r;   r   rt   r{   r|   r~   r2   r   )r   r   rt   r   )rW   r   rX   r   r;   r   rt   r   )r  r   rt   Iterator[Any])rW   r   rX   r   r;   r   rt   r  )r  r   rt   AsyncIterator[Any])rW   r   rX   r   r;   r   rt   r  )rW   r   rX   r   r;   r   rt   r  )rW   r   rX   r   r;   r   rt   r  )r   r   r   r   r   r:   r   r   rA   rH   r   r  rY   r   r\   r   re   r   rh   rl   rx   r   r   s   @r%   r   r     s9   "H .    3  3 3 3 3
  )-KK &K 	K
 
K K!! 
!  )-UU &U 	U
 
U U( 
  )-
'
 &
 	

 

 
- 
  )-	,	 &	 		
 
	 	  )-?? &? 	?
 
? ?  )-

 &
 	

 

 
r'   r   )r$   r   rt   r   )8r   
__future__r   r   r7   r   collections.abcr   r   typingr   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   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   rQ   rR   rP   r   r"   r'   r%   <module>r!     s    0 "    /  * &   , - 9@@ 5		P.ue|< Pf +>*? ' ?|)$sCx.$sCx.*HI |~	j'S#X(;< jr'   