
    D_iqe              	         % S r SSKJr  SSKrSSKrSSKrSSKJrJr  SSK	J
r
JrJr  SSKJrJr  SSKJr  SSKJrJrJrJr  SS	KJrJrJrJrJrJr  SS
KJrJ r   SSK!J"r"  SSK#J$r$  SSK%J&r&  \
(       a  SSKJ'r'J(r(J)r)  SSK*J+r+J,r,  SSK-J.r.  SS jr/SS jr0 " S S\\\4   5      r1\1" 5       r2S\3S'    " S S\\4\5\4   \4\5\4   4   5      r6 " S S\\4\5\4   \4   5      r7g)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                    U $ )z>Identity function.

Args:
    x: Input.

Returns:
    Output.
 xs    ^/home/james-whalen/.local/lib/python3.13/site-packages/langchain_core/runnables/passthrough.pyidentityr&   2   s	     H    c                   #    U $ 7f)zDAsync identity function.

Args:
    x: Input.

Returns:
    Output.
r"   r#   s    r%   	aidentityr)   >   s      Hs   c                    ^  \ rS rSr% SrSrS\S'   SrS\S'   SrS\S	'   \	SS
 j5       r
  SSS.         SU 4S jjjjr\\	SS j5       5       r\SS j5       r\\	SS j5       5       r\\	SS j5       5       r\\	    SS j5       5       r\	 S       S S jj5       r\	 S       S!S jj5       r\	 S       S"S jj5       r\	 S       S#S jj5       r\	 S       S$S jj5       r\	 S       S%S jj5       rSrU =r$ )&RunnablePassthroughJ   a  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                    / $ Nr"   selfs    r%   __repr_args__!RunnablePassthrough.__repr_args__   s	     	r'   )r.   c               j   > [         R                  " U5      (       a  UnSn[        TU ]  " SXUS.UD6  g)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/   r1   r.   r"   )inspectiscoroutinefunctionsuper__init__)r5   r/   r1   r.   kwargs	__class__s        r%   r<   RunnablePassthrough.__init__   s7    * &&t,,EDQdJQ&Qr'   c                    gz,Return `True` as this class is serializable.Tr"   clss    r%   is_lc_serializable&RunnablePassthrough.is_lc_serializable        r'   c                
    / SQ$ z_Get the namespace of the LangChain object.

Returns:
    `["langchain", "schema", "runnable"]`
)	langchainschemarunnabler"   rB   s    r%   get_lc_namespace$RunnablePassthrough.get_lc_namespace   s
     32r'   c                4    U R                   =(       d    [        $ r3   r.   r   r4   s    r%   	InputTypeRunnablePassthrough.InputType        %#%r'   c                4    U R                   =(       d    [        $ r3   rO   r4   s    r%   
OutputTypeRunnablePassthrough.OutputType   rR   r'   c                T    [        [        [        [        [        4      " U5      5      $ )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   )rC   r=   s     r%   assignRunnablePassthrough.assign   s"    $ .tCH~>vFGGr'   c                    U R                   b!  [        U R                   U[        U5      40 UD6  U R                  [        X5      $ r3   )r/   r   r   _call_with_configr&   r5   inputconfigr=   s       r%   invokeRunnablePassthrough.invoke   sC     99 (		5-"7;A %%h>>r'   c                  #    U R                   b*  [        U R                   U[        U5      40 UD6I S h  vN   O.U R                  b!  [	        U R                  U[        U5      40 UD6  U R                  [        X5      I S h  vN $  NQ N7fr3   )r1   r   r   r/   r   _acall_with_configr)   r^   s       r%   ainvokeRunnablePassthrough.ainvoke   s      ::!/

E=#8<B   YY"(		5-"7;A ,,YFFF Gs"   2B
BAB
BB
B
c              +  R  #    U R                   c#  U R                  U[        U5       H  nUv   M	     g SnU R                  U[        U5       H  nUv   U(       d  UnSnM   WU-   nM     U(       a"  [	        U R                   W[        U5      40 UD6  g g ! [         a    Un MW  f = f7fNFT)r/   _transform_stream_with_configr&   	TypeErrorr   r   r5   r_   r`   r=   chunkgot_first_chunkfinals          r%   	transformRunnablePassthrough.transform   s      99;;E8VT U $O;;E8VT&!E&*O& % U ,IIumF&;?E  % & %&s*   AB'!B&.B'B$ B'#B$$B'c               
  #    U R                   c4  U R                  c'  U R                  U[        U5        S h  vN nU7v   M  SnU R                  U[        U5        S h  vN nU7v   U(       d  UnSnM   WU-   nM#   NG
 g  N"! [         a    Un M8  f = f
 U(       aa  [        U5      nU R                   b"  [        U R                   WU40 UD6I S h  vN    g U R                  b  [        U R                  WU40 UD6  g g g 7frh   )r1   r/   _atransform_stream_with_configr&   rj   r   r   r   rk   s          r%   
atransform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   2DBB B!DB!B"B%D9B>D BDBBDB>DC.Dc                >    U R                   " [        U/5      U40 UD6$ r3   ro   iterr^   s       r%   streamRunnablePassthrough.streamF        ~~dE7mV>v>>r'   c               v   ^#    SU4S jjnU R                   " U" 5       U40 UD6  S h  vN nU7v   M   N
 g 7f)Nc                   >#    T 7v   g 7fr3   r"   r_   s   r%   input_aiter0RunnablePassthrough.astream.<locals>.input_aiterV       K   
)returnAsyncIterator[Other]rs   r5   r_   r`   r=   r~   rl   s    `    r%   astreamRunnablePassthrough.astreamO  6     	  ??;=&KFK 	%K	K   "9757979r"   )r   r   )NN)
r/   zCallable[[Other], None] | Callable[[Other, RunnableConfig], None] | Callable[[Other], Awaitable[None]] | Callable[[Other, RunnableConfig], Awaitable[None]] | Noner1   r0   r.   r-   r=   r   r   Noner   boolr   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]]r   rW   r3   )r_   r   r`   RunnableConfig | Noner=   r   r   r   )r_   r   r`   r   r=   
Any | Noner   r   )r_   Iterator[Other]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=   r   r   r   )__name__
__module____qualname____firstlineno____doc__r.   __annotations__r/   r1   r   r6   r<   classmethodrD   rL   propertyrP   rT   rZ   ra   re   ro   rs   rx   r   __static_attributes____classcell__r>   s   @r%   r+   r+   J   s   :x &*J") 	 	
R  		 
	    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                    ^  \ rS rSr% SrS\S'   SU 4S jjr\\SS j5       5       r	\\SS j5       5       r
\SSS	.SU 4S
 jjjj5       r\SSU 4S jjj5       r\ S   SU 4S jjj5       r\\S S j5       5       r\SS!S jj5       r          S"S jr\ S       S#S jj5       r          S$S jr\ S       S#S jj5       r          S%S jr\ S       S&S jj5       r          S'S jr\ S       S(S jj5       r\ S       S)S jj5       r\ S       S*S jj5       rSrU =r$ )+rW   i`  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:
    ```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U ]  " SSU0UD6  g)zCreate a `RunnableAssign`.

Args:
    mapper: A `RunnableParallel` instance that will be used to transform the
        input dictionary.
r   Nr"   r;   r<   )r5   r   r=   r>   s      r%   r<   RunnableAssign.__init__  s     	11&1r'   c                    grA   r"   rB   s    r%   rD   !RunnableAssign.is_lc_serializable  rF   r'   c                
    / SQ$ rH   r"   rB   s    r%   rL   RunnableAssign.get_lc_namespace  
     32r'   Nnamec                  > U=(       dJ    U R                   =(       d7    SSR                  U R                  R                  R	                  5       5       S3n[
        TU ]  XS9$ )NzRunnableAssign<,>r   )r   joinr   steps__keysr;   get_namer5   suffixr   r>   s      r%   r   RunnableAssign.get_name  s^      IyyI $++*=*=*B*B*D!E FaH 	
 w22r'   c                   > U R                   R                  U5      n[        U[        5      (       d  U$ [        TU ]  U5      $ r3   )r   get_input_schema
issubclassr
   r;   )r5   r`   map_input_schemar>   s      r%   r   RunnableAssign.get_input_schema  s<    ;;77?*I66##w'//r'   c                  > U R                   R                  U5      nU R                   R                  U5      n[        U[        5      (       d  [        U[        5      (       d  0 nUR
                  R                  5        H  u  pVUR                  UR                  4XE'   M!     UR
                  R                  5        H  u  pVUR                  UR                  4XE'   M!     [        SUS9$ [        U[        5      (       d  U$ [        TU ]	  U5      $ )NRunnableAssignOutput)field_definitions)r   r   get_output_schemar   r
   model_fieldsitems
annotationdefaultr   r;   )r5   r`   r   map_output_schemafieldsr   
field_infor>   s          r%   r    RunnableAssign.get_output_schema  s      ;;77? KK99&A*I66zy@
 @
 F$4$A$A$G$G$I  * 5 5z7I7IJ %J %6$B$B$H$H$J  * 5 5z7I7IJ %K ##9VTT+Y77 %$w(00r'   c                .    U R                   R                  $ r3   )r   config_specsr4   s    r%   r   RunnableAssign.config_specs  s     {{'''r'   c                    U R                   R                  U5      nUR                  5       nUR                  5       nUb:  Ub7  UR	                  [
        5      nUR                  X55        UR                  XT5        U$ r3   )r   	get_graph
first_node	last_nodeadd_noder   add_edge)r5   r`   graph
input_nodeoutput_nodepassthrough_nodes         r%   r   RunnableAssign.get_graph  sk     %%f-%%'
oo'!k&=$~~.@ANN:8NN+9r'   c           	         [        U[        5      (       d  Sn[        U5      e0 UEU R                  R                  " U[        X2R                  5       S940 UD6E$ N9The input to RunnablePassthrough.assign() must be a dict.	callbacks)
isinstancerX   
ValueErrorr   ra   r   	get_childr5   valuerun_managerr`   r=   msgs         r%   _invokeRunnableAssign._invoke  sg     %&&MCS/!

kk  V/D/D/FG 
 	
r'   c                >    U R                   " U R                  X40 UD6$ r3   )r]   r   r^   s       r%   ra   RunnableAssign.invoke  s      %%dllELVLLr'   c           	        #    [        U[        5      (       d  Sn[        U5      e0 UEU R                  R                  " U[        X2R                  5       S940 UD6I S h  vN E$  N7fr   )r   rX   r   r   re   r   r   r   s         r%   _ainvokeRunnableAssign._ainvoke  st      %&&MCS/!

KK''V/D/D/FG  
 	
s   AA&A$A&c                Z   #    U R                   " U R                  X40 UD6I S h  vN $  N7fr3   rd   r   r^   s       r%   re   RunnableAssign.ainvoke  )      ,,T]]ETVTTTT   "+)+c           
   +    #    [        U R                  R                  R                  5       5      n[	        US[
        R                  " 5       S9u  pgU R                  R                  " U[        UUR                  5       S940 UD6n[        U5       n	U	R                  [        US 5      n
U Hg  n[        U[        5      (       d  Sn[        U5      e[!        UR#                  5        VVs0 s H  u  pX;  d  M  X_M     snn5      nU(       d  Mc  Uv   Mi     [%        SU
R'                  5       5      v   U H  nUv   M	     S S S 5        g s  snnf ! , (       d  f       g = f7f)N   lockr   r   dict[str, Any])setr   r   r   r   	threadingLockro   r   r   r   submitnextr   rX   r   r   r   r   result)r5   valuesr   r`   r=   mapper_keysfor_passthroughfor_map
map_outputexecutorfirst_map_chunk_futurerl   r   kvfiltereds                   r%   
_transformRunnableAssign._transform  s:     $++--2245#*619>>;K#L  [[**%//1
 

 %V,%-__&" )!%..UC$S/)&&+kkmLmdaq7KTQTmL 8"N ) ')?)F)F)HII# $) -, M -,s=   BEAE&E5E;E1E=	EE
EEc              +  \   #    U R                   " XR                  U40 UD6 S h  vN   g  N7fr3   ri   r   r^   s       r%   ro   RunnableAssign.transformH  0      55??F
.4
 	
 	
   ",*,c           	      #    [        U R                  R                  R                  5       5      n[	        US[
        R                  " 5       S9u  pgU R                  R                  " U[        UUR                  5       S940 UD6n[
        R                  " [        US 5      5      n	U  S h  vN n
[        U
[        5      (       d  Sn[        U5      e[        U
R!                  5        VVs0 s H  u  pX;  d  M  X_M     snn5      nU(       d  Mi  U7v   Mp   Nks  snnf 
 U	I S h  vN  7v   U  S h  vN  n
U
7v   M  
 g 7f)Nr   r   r   r   )r   r   r   r   r   asyncior   rs   r   r   create_taskanextr   rX   r   r   r   )r5   r   r   r`   r=   r   r   r   r   first_map_chunk_taskrl   r   r   r   r   s                  r%   _atransformRunnableAssign._atransformS  s*     $++--2245#'#G [[++%//1
 

 .5-@-@*d#.
 + 
	%eT**Q o% #"'++-H-$!13G-HH x
	 I + )(((% 	 	%K &sf   B$E&D*D+D.;E)D8D>EEDE$D'%
E/E 3D64E 8
Ec               n   #    U R                   " XR                  U40 UD6  S h  vN nU7v   M   N
 g 7fr3   rr   r  r5   r_   r`   r=   rl   s        r%   rs   RunnableAssign.atransform|  @       >>##V
/5
 	% K	 
   5313535c                >    U R                   " [        U/5      U40 UD6$ r3   rv   r^   s       r%   rx   RunnableAssign.stream  rz   r'   c               v   ^#    SU4S jjnU R                   " U" 5       U40 UD6  S h  vN nU7v   M   N
 g 7f)Nc                   >#    T 7v   g 7fr3   r"   r}   s   r%   r~   +RunnableAssign.astream.<locals>.input_aiter  r   r   r   AsyncIterator[dict[str, Any]]r   r   s    `    r%   r   RunnableAssign.astream  r   r   r"   )r   z RunnableParallel[dict[str, Any]]r=   r   r   r   r   r   r3   r   
str | Noner   r  r   rY   )r`   r   r   ztype[BaseModel])r   zlist[ConfigurableFieldSpec])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`   r   r=   r   r   r   )
r   Iterator[dict[str, Any]]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_   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   r   r   r<   r   r   rD   rL   r   r   r   r   r   r   r   ra   r   re   r   ro   r  rs   rx   r   r   r   r   s   @r%   rW   rW   `  s:   %N 2    3  3 3 3 3 3 0 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'   rW   c                    ^  \ rS rSr% SrS\S'   SU 4S jjr\\SS j5       5       r	\\SS j5       5       r
\SSS	.SU 4S
 jjjj5       rSS jr\ S       SS jj5       r    SS jr\ S       SS jj5       r    SS jr\ S       SS jj5       r    SS jr\ S       S S jj5       r\ S       S!S jj5       r\ S       S"S jj5       rSrU =r$ )#RunnablePicki  as  `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U ]  " SSU0UD6  g)zlCreate a `RunnablePick`.

Args:
    keys: A single key or a list of keys to pick from the input dictionary.
r   Nr"   r   )r5   r   r=   r>   s      r%   r<   RunnablePick.__init__  s     	-d-f-r'   c                    grA   r"   rB   s    r%   rD   RunnablePick.is_lc_serializable  rF   r'   c                
    / SQ$ rH   r"   rB   s    r%   rL   RunnablePick.get_lc_namespace  r   r'   Nr   c                  > U=(       d^    U R                   =(       dK    SSR                  [        U R                  [        5      (       a  U R                  /OU R                  5       S3n[
        TU ]  XS9$ )NzRunnablePick<r   r   r   )r   r   r   r   rY   r;   r   r   s      r%   r   RunnablePick.get_name  sn      VyyV
499c(B(B$))		RSSTV 	 w22r'   c                N   [        U[        5      (       d  Sn[        U5      e[        U R                  [        5      (       a  UR                  U R                  5      $ U R                   Vs0 s H  o3U;   d  M
  X1R                  U5      _M     nnU(       a  [        U5      $ g s  snf )Nr   )r   rX   r   r   rY   getr   )r5   r   r   r   pickeds        r%   _pickRunnablePick._pick  s    %&&MCS/!dii%%99TYY''+/99C9aU
/!YYq\/9Cv&& Ds   +	B"8B"c                >    U R                   " U R                  X40 UD6$ r3   )r]   r,  r^   s       r%   ra   RunnablePick.invoke  s      %%djj%J6JJr'   c                ,   #    U R                  U5      $ 7fr3   r,  )r5   r   s     r%   r   RunnablePick._ainvoke  s      zz%  s   c                Z   #    U R                   " U R                  X40 UD6I S h  vN $  N7fr3   r   r^   s       r%   re   RunnablePick.ainvoke  r   r   c              #  R   #    U H  nU R                  U5      nUc  M  Uv   M     g 7fr3   r1  r5   chunksrl   r+  s       r%   r   RunnablePick._transform  s*      EZZ&F! s   '	'c              +  \   #    U R                   " XR                  U40 UD6 S h  vN   g  N7fr3   r  r^   s       r%   ro   RunnablePick.transform  r  r  c               b   #    U  S h  vN nU R                  U5      nUc  M  U7v   M&   N!
 g 7fr3   r1  r6  s       r%   r  RunnablePick._atransform   s1      " 	%ZZ&F!	6s    /-+-//-/c               n   #    U R                   " XR                  U40 UD6  S h  vN nU7v   M   N
 g 7fr3   r  r  s        r%   rs   RunnablePick.atransform)  r  r  c                >    U R                   " [        U/5      U40 UD6$ r3   rv   r^   s       r%   rx   RunnablePick.stream5  rz   r'   c               v   ^#    SU4S jjnU R                   " U" 5       U40 UD6  S h  vN nU7v   M   N
 g 7f)Nc                   >#    T 7v   g 7fr3   r"   r}   s   r%   r~   )RunnablePick.astream.<locals>.input_aiterE  r   r   r  r   r   s    `    r%   r   RunnablePick.astream>  r   r   r"   )r   r   r=   r   r   r   r   r   r3   r  )r   r   r   r   )r_   r   r`   r   r=   r   r   r   )r7  r  r   Iterator[Any])r_   r  r`   r   r=   r   r   rE  )r7  r  r   AsyncIterator[Any])r_   r  r`   r   r=   r   r   rF  )r_   r   r`   r   r=   r   r   rE  )r_   r   r`   r   r=   r   r   rF  )r   r   r   r   r   r   r<   r   r   rD   rL   r   r,  ra   r   re   r   ro   r  rs   rx   r   r   r   r   s   @r%   r  r    s>   "H .    3  3 3 3 3 3
  )-KK &K 	K
 
K K!! 
!  )-UU &U 	U
 
U U( 
  )-
'
 &
 	

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