9i ddlmZddlZddlZddlZddlZddlmZddlm Z m Z m Z m Z ddl mZddlmZmZmZmZddlmZddlmZdd lmZmZmZmZmZmZmZmZmZdd lm Z m!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'ddl(m)Z)m*Z*ddl+m,Z,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2m3Z3m4Z4m5Z5ddl6m7Z7m8Z8m9Z9ddl:m;Z;ddlm?Z?m@Z@mAZAddlBmCZCddlDmEZEddlFmGZGddlHmIZImJZJddlKmLZLmMZMddlNmOZOmPZPmQZQddlRmSZSmTZTmUZUmVZVddlWmXZXddlYmZZZm[Z[ddl\m]Z]m^Z^ddl_m`Z`dd lambZbmcZcdd!ldmeZemfZfmgZgdd"lhmiZimjZjmkZkmlZlmmZmmnZndd#lompZpmqZqmrZrmsZsmtZtdd$lumvZvmwZwd%ZxejezZ{d&Z|dd-Zd?d.Zd@d/Z dAd0ZdBd1Z dCd2Ze dDd3Zed4d5 dEd6Zd4d5 dFd7ZdGd8ZdHd9ZdId:Z dJd;Zy)K) annotationsN) defaultdict) AwaitableCallableHashableSequence)partial)isclass isfunctionismethod signature) FunctionType)NoneType) AnyGenericLiteralUnioncastget_args get_originget_type_hintsoverload)RunnableRunnableConfig) BaseCache) Checkpoint) BaseStore) BaseModel TypeAdapter) NotRequiredRequiredSelfUnpack is_typeddict) INTERRUPTNS_ENDNS_SEPTASKS)get_cached_annotated_keysget_field_defaultget_update_as_tuples) create_model)coerce_to_runnable) EMPTY_SEQMISSINGDeprecatedKwargs) BaseChannel)BinaryOperatorAggregate)EphemeralValue) LastValueLastValueAfterFinish)NamedBarrierValueNamedBarrierValueAfterFinish)ENDSTART TAG_HIDDEN) ErrorCodeInvalidUpdateError ParentCommandcreate_error_message) BranchSpec) StateNode StateNodeSpec)ManagedValueSpecis_managed_value)Pregel) ChannelRead PregelNode) ChannelWriteChannelWriteEntryChannelWriteTupleEntry)All CachePolicy CheckpointerCommand RetryPolicySend)ContextTInputT NodeInputTOutputTStateT)LangGraphDeprecatedSinceV05LangGraphDeprecatedSinceV10) StateGraphCompiledStateGraphz branch:to:{}ct|trytj|ryt j d|dy)NzInvalid state_schema: z. Expected a type or Annotated[type, reducer]. Please provide a valid schema to ensure correct updates. See: https://langchain-ai.github.io/langgraph/reference/graphs/#stategraph) isinstancetypetypingrwarningswarn)schemas _/var/www/html/backtest/airagagent/rag_env/lib/python3.12/site-packages/langgraph/graph/state.py_warn_invalid_state_schemara\s=&$ v MM )V Vc t|d|jjS#t$rt dt |wxYw)N__name__zUnsupported node type: )getattr __class__rdAttributeError TypeErrorr[)nodes r`_get_node_namerjhsI@tZ)@)@AA @1$t*>??@s #!AceZdZUdZded<ded<ded<ded <d ed <d ed <ded<ded<ded<ded<ded<ded< d0ddd d1dZed2dZd3d4dZe ddddddd  d5d!Z e dddddd" d6d#Z e ddddddd  d7d$Z e d0dddddd" d8d%Z d0ddddddd  d9d&Z d:d'Z d0 d;d(Z dd+Zd=d,Zd0d?d-Z d0ddddddd. d@d/Zy)ArWa A graph whose nodes communicate by reading and writing to a shared state. The signature of each node is `State -> Partial`. Each state key can optionally be annotated with a reducer function that will be used to aggregate the values of that key received from multiple nodes. The signature of a reducer function is `(Value, Value) -> Value`. !!! warning `StateGraph` is a builder class and cannot be used directly for execution. You must first call `.compile()` to create an executable graph that supports methods like `invoke()`, `stream()`, `astream()`, and `ainvoke()`. See the `CompiledStateGraph` documentation for more details. Args: state_schema: The schema class that defines the state. context_schema: The schema class that defines the runtime context. Use this to expose immutable context data to your nodes, like `user_id`, `db_conn`, etc. input_schema: The schema class that defines the input to the graph. output_schema: The schema class that defines the output from the graph. !!! warning "`config_schema` Deprecated" The `config_schema` parameter is deprecated in v0.6.0 and support will be removed in v2.0.0. Please use `context_schema` instead to specify the schema for run-scoped context. Example: ```python from langchain_core.runnables import RunnableConfig from typing_extensions import Annotated, TypedDict from langgraph.checkpoint.memory import InMemorySaver from langgraph.graph import StateGraph from langgraph.runtime import Runtime def reducer(a: list, b: int | None) -> list: if b is not None: return a + [b] return a class State(TypedDict): x: Annotated[list, reducer] class Context(TypedDict): r: float graph = StateGraph(state_schema=State, context_schema=Context) def node(state: State, runtime: Runtime[Context]) -> dict: r = runtime.context.get("r", 1.0) x = state["x"][-1] next_value = x * r * (1 - x) return {"x": next_value} graph.add_node("A", node) graph.set_entry_point("A") graph.set_finish_point("A") compiled = graph.compile() step1 = compiled.invoke({"x": 0.5}, context={"r": 3.0}) # {'x': [0.5, 0.75]} ``` set[tuple[str, str]]edgesz'dict[str, StateNodeSpec[Any, ContextT]]nodesz'defaultdict[str, dict[str, BranchSpec]]brancheszdict[str, BaseChannel]channelszdict[str, ManagedValueSpec]managedz:dict[type[Any], dict[str, BaseChannel | ManagedValueSpec]]schemasz set[tuple[tuple[str, ...], str]] waiting_edgesboolcompiled type[StateT] state_schematype[ContextT] | Nonecontext_schemaz type[InputT] input_schemaz type[OutputT] output_schemaN)rzr{c |jdtx}tur5tjdtd|t t t|}|jdtx}tur5tjdtd|t t t|}|jdtx}tur5tjdtd|t t t|}i|_ t|_ tt|_i|_i|_i|_d |_t|_||_t t t|xs||_t t t|xs||_||_|j5|j,|j5|j.d |j5|j0d y) N config_schemazW`config_schema` is deprecated and will be removed. Please use `context_schema` instead.)category stacklevelinputM`input` is deprecated and will be removed. Please use `input_schema` instead.outputzO`output` is deprecated and will be removed. Please use `output_schema` instead.F allow_managed)getr/r]r^rVrr[rPrUrQrSrnsetrmrdictrorrrprqrursrwrzr{ry _add_schema) selfrwryrzr{kwargsr}input_rs r`__init__zStateGraph.__init__s$ZZA AM' Q MMi4  %!%d8nm!Djj'2 2F7 B MM_4  ##DL&9 jj73 3FG C MMa4  $ $T']F ;  U #D)      U( f|/K|L!$w-1N,O, **+ **%@ ++5Arbc ~|j|jDchc]\}}|D]}||fc}}}zScc}}}wN)rmrs)rstartsendstarts r` _all_edgeszStateGraph._all_edgessPzz,0,>,>  (VSF CHUCL     s8 cd||jvr!t|t|\}}}|r2|s0dj|}t |dd}t d|d|di|||j|<|j D]U\}} ||jvr3|j|| k7s't| tr8t d|d| |j|<W|j D]D\}}||jvr"|j||k7s't d |d||j|<Fyy) Nz, rdz%Invalid managed channels detected in z: z<. Managed channels are not permitted in Input/Output schema.z Channel 'z&' already exists with a different typezManaged value ') rrra _get_channelsjoinre ValueErroritemsrprZr4rq) rr_rrprq type_hintsnames schema_namekeychannels r`rzStateGraph._add_schemas^  % &v .,9&,A )Hgz} '*%fj"=  ;K=5'RRR$;h#:'#:DLL ( 0 1 W$--'}}S)W4%gy9 ","+C50V W#*1DMM#& 1!(  0 W$,,&||C(G3(-cU2XY)0DLL% 0- &rbF)defermetadatarz retry_policy cache_policy destinationsc y)zAdd a new node to the `StateGraph`, input schema is inferred as the state schema. Will take the name of the function/runnable as the node name. N rrirrrzrrrrs r`add_nodezStateGraph.add_node  rb)rrrrrc y)zAdd a new node to the `StateGraph`, input schema is specified. Will take the name of the function/runnable as the node name. Nrrs r`rzStateGraph.add_node2rrbc y)zQAdd a new node to the `StateGraph`, input schema is inferred as the state schema.Nr rriactionrrrzrrrrs r`rzStateGraph.add_nodeD rbc y)z>Add a new node to the `StateGraph`, input schema is specified.Nrrs r`rzStateGraph.add_nodeUrrbc | jdtx} turtjdt|| }| jdtx} tur7tjdt|t t tdz| }t|tsQ|}t|tr|j}n!t|d|jj}| td|j rt"j%d t|ts5|}t tt|d t|dd}| td|t&||j(vrtd |d |t*k(s |t,k(rtd |d t.t0fD]} | |vstd| dd} t2} t5|s"t7|st7t|ddr0t9t|dxs t9|x}r |}t;t=t?j@t tB|jDjG}|j|x}rt|t r t9|r|} |jdx}rytI|}|tJur+tM|}|D]}tI|}|tNus|}|}n|tNur3tM|x}r&tI|dtPurtM|dx}r|}||}|9tYttZft]||d|||||||j(|<np| ,tYt]||d|| |||||j(|<nBtYt^tZft]||d||j`|||||j(|<|xs| }||jc||S#tRtTtVf$rYwxYw)a Add a new node to the `StateGraph`. Args: node: The function or runnable this node will run. If a string is provided, it will be used as the node name, and action will be used as the function or runnable. action: The action associated with the node. Will be used as the node function or runnable if `node` is a string (node name). defer: Whether to defer the execution of the node until the run is about to end. metadata: The metadata associated with the node. input_schema: The input schema for the node. (Default: the graph's state schema) retry_policy: The retry policy for the node. If a sequence is provided, the first matching policy will be applied. cache_policy: The cache policy for the node. destinations: Destinations that indicate where a node can route to. Useful for edgeless graphs with nodes that return `Command` objects. If a `dict` is provided, the keys will be used as the target node names and the values will be used as the labels for the edges. If a `tuple` is provided, the values will be used as the target node names. !!! note This is only used for graph rendering and doesn't have any effect on the graph execution. Example: ```python from typing_extensions import TypedDict from langchain_core.runnables import RunnableConfig from langgraph.graph import START, StateGraph class State(TypedDict): x: int def my_node(state: State, config: RunnableConfig) -> State: return {"x": state["x"] + 1} builder = StateGraph(State) builder.add_node(my_node) # node name will be 'my_node' builder.add_edge(START, "my_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Example: Customize the name: ```python builder = StateGraph(State) builder.add_node("my_fair_node", my_node) builder.add_edge(START, "my_fair_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Returns: Self: The instance of the `StateGraph`, allowing for method chaining. retryzM`retry` is deprecated and will be removed. Please use `retry_policy` instead.)rNrrrdz6Node name must be provided if action is not a functionzjAdding a node to a graph that has already been compiled. This will not be reflected in the compiled graph.namezNode `z` already present.z` is reserved.'z?' is a reserved character and is not allowed in the node names.__call__returnrFrtrace)rzrrendsr)2rr/r]r^rUrr[rRrZstrrget_namererfrdrruloggerwarning RuntimeErrorrnr8r9r'r&r.r r rnextiterinspectr r parameterskeysrrrrMr NameErrorrh StopIterationrArPr-rTrwr)rrirrrrzrrrrrr characterinferred_input_schemarhintsfirst_parameter_name input_hintrtn rtn_originrtn_argsarg arg_originrargsvalss r`rzStateGraph.add_nodefs-ZZZ1 1E' A MM_4 #$ jj'2 2F7 B MM_4 ##D$4t$;VD $$F&(+(vz63C3C3L3LM| L == NN: $$FWVVWVZQU5VWXD| L >  4:: vdV+=>? ? 3;$%-vdV>:; ; &) ID   {"ab  !%1:* 6"F#GFJ=>' (CD*!&)** '+/#-- $\6 :(j,(&+YY/C%DDzD%j$7N:1))H--3-!+CJ!U*#+C=#+&C)3CJ)W4&)-7 % &#g-&.sm3U3&uQx0G;%-eAh%77T7#  #D  #,Z-AB"6EB))) DJJt # .,"6EB2)) DJJt  -VX-=>"6EB!..)) DJJt $<'<  #   \ * S9m4   s DO4(AO44P  P c|jrtjdt|tr|t k(r t d|tk(r t dt|ds-|td|jDvrt d|d|jj||f|S|D]3}|t k(r t d||jvs&t d|d |tk(r t d|t k7r||jvrt d|d |jjt||f|S) aAdd a directed edge from the start node (or list of start nodes) to the end node. When a single start node is provided, the graph will wait for that node to complete before executing the end node. When multiple start nodes are provided, the graph will wait for ALL of the start nodes to complete before executing the end node. Args: start_key: The key(s) of the start node(s) of the edge. end_key: The key of the end node of the edge. Raises: ValueError: If the start key is `'END'` or if the start key or end key is not present in the graph. Returns: Self: The instance of the `StateGraph`, allowing for method chaining. kAdding an edge to a graph that has already been compiled. This will not be reflected in the compiled graph.zEND cannot be a start nodezSTART cannot be an end noderpc3&K|] \}}| ywrr).0r_s r` z&StateGraph.add_edge..[sB"%BszAlready found path for node 'zB'. For multiple edges, use StateGraph with an Annotated state key.zNeed to add_node `z` first)rurrrZrr8rr9hasattrrrmaddrnrstuple)r start_keyend_keyrs r`add_edgezStateGraph.add_edge=s`" == NN:  i %C !=>>% !>??4,cB&*jjB?2!3I;?VV JJNNIw/ 0K FE| !=>>DJJ& #5eWG!DEE  F e :; ; c>gTZZ71''BC C i 0':; rbc|jrtjdt|dd}|jxsd}||j |vrt d|jd|dtj||d|j ||<|j ||jx}r|j||S) aAdd a conditional edge from the starting node to any number of destination nodes. Args: source: The starting node. This conditional edge will run when exiting this node. path: The callable that determines the next node or nodes. If not specifying `path_map` it should return one or more nodes. If it returns `'END'`, the graph will stop execution. path_map: Optional mapping of paths to node names. If omitted the paths returned by `path` should be node names. Returns: Self: The instance of the graph, allowing for method chaining. !!! warning Without type hints on the `path` function's return value (e.g., `-> Literal["foo", "__end__"]:`) or a path_map, the graph visualization assumes the edge could transition to any node in the graph. rNTr conditionzBranch with name `z` already exists for node ``) rurrr-rrorr? from_pathrzr)rsourcepathpath_maprr_s r`add_conditional_edgesz StateGraph.add_conditional_edgesss< == NN:  "$T>yy'K 4==( ($TYYK/J6(RST '1&:&:44&P fd#]]6*40== =6 =   V $ rbc2t|dkr tdd}|D]v}t|trt|dk(r|\}}n t |}||j vrtd|d|j ||||j|||}x|S)aAdd a sequence of nodes that will be executed in the provided order. Args: nodes: A sequence of `StateNode` (callables that accept a `state` arg) or `(name, StateNode)` tuples. If no names are provided, the name will be inferred from the node object (e.g. a `Runnable` or a `Callable` name). Each node will be executed in the order provided. Raises: ValueError: If the sequence is empty. ValueError: If the sequence contains duplicate node names. Returns: Self: The instance of the `StateGraph`, allowing for method chaining. z$Sequence requires at least one node.Nr~z/Node names must be unique: node with the name 'z' already exists. If you need to use two different runnables/callables with the same name (for example, using `lambda`), please provide them as tuples (name, runnable/callable).)lenrrZrrjrnrr)rrn previous_namerirs r` add_sequencezStateGraph.add_sequences. u:>CD D$(  !D$&3t9>! d%d+tzz! EdVLvv MM$ %( mT2 M! !$ rbc.|jt|S)a+Specifies the first node to be called in the graph. Equivalent to calling `add_edge(START, key)`. Parameters: key (str): The key of the node to set as the entry point. Returns: Self: The instance of the graph, allowing for method chaining. )rr9rrs r`set_entry_pointzStateGraph.set_entry_points}}UC((rbc0|jt||S)a Sets a conditional entry point in the graph. Args: path: The callable that determines the next node or nodes. If not specifying `path_map` it should return one or more nodes. If it returns END, the graph will stop execution. path_map: Optional mapping of paths to node names. If omitted the paths returned by `path` should be node names. Returns: Self: The instance of the graph, allowing for method chaining. )rr9)rrrs r`set_conditional_entry_pointz&StateGraph.set_conditional_entry_points,))%x@@rbc.|j|tS)a0Marks a node as a finish point of the graph. If the graph reaches this node, it will cease execution. Parameters: key (str): The key of the node to set as the finish point. Returns: Self: The instance of the graph, allowing for method chaining. )rr8rs r`set_finish_pointzStateGraph.set_finish_points}}S#&&rbc |jDchc]\}}| }}}|jjD]\}}|j||jjD]#\}}|j s|j|%|D])} | |jvs| t k7std| dt |vr td|jD chc]\}} |  } }} |jjD]\}}|jD]\} } | j ]| j jD]?} | |jvr| tk7rtd|d| d| d| j| Ao| jt|jD]}||k7s | j||jjD]-\}}|j s| j|j /| D])}||jvs|tk7std|d|r$|D]}||jvstd |d d |_ |Scc}}wcc} }w) Nz%Found edge starting at unknown node 'rzOGraph must have an entrypoint: add at least one edge from START to another nodezAt 'z ' node, 'z' branch found unknown target 'z#Found edge ending at unknown node `rzInterrupt node `z ` not foundT) rrorrrnrr9rvaluesr8updateru)r interruptsrcr all_sourcesrrorspecrr all_targetscondbranchritargets r`validatezStateGraph.validates)-9vsAs9 9#}}224 #OE8 OOE " #****, &JD$yy% &" TFTZZ'FeO #HPQ!RSS T  #a  *.9vq#s9 9#}}224 2OE8 ( 0 2 f;;*%{{113-djj0SCZ","&ugYtf<[\_[``a b#$, - OOC( $ 25='OOD12 2 2****, .JD$yy""499- ." RFTZZ'FcM #Fvha!PQQ R ! Ktzz)$'7v[%IJJ K  [:":s I8" I>)cachestoreinterrupt_beforeinterrupt_afterdebugrc ^|xsg}|xsg}|j|dk7r |dk7r|ng|zngt|j|jdk(rd|j|jvrdnD|j|jj D cgc]\}} t | s|c} }} t|j dk(rd|j vrdn8|j j D cgc]\}} t | r|c} }} tttttfdid|did|jdid i|j |jtt|j id td d d | d| d|d|d|ddd|d|d|d|xsd} | j#td|j$j D]\}} | j#|| |j&D]\}}| j)|||j*D]\}}| j)|||j,j D]0\}}|j D]\}}| j/|||2| jScc} }wcc} }w)aCompiles the `StateGraph` into a `CompiledStateGraph` object. The compiled graph implements the `Runnable` interface and can be invoked, streamed, batched, and run asynchronously. Args: checkpointer: A checkpoint saver object or flag. If provided, this `Checkpointer` serves as a fully versioned "short-term memory" for the graph, allowing it to be paused, resumed, and replayed from any point. If `None`, it may inherit the parent graph's checkpointer when used as a subgraph. If `False`, it will not use or inherit any checkpointer. interrupt_before: An optional list of node names to interrupt before. interrupt_after: An optional list of node names to interrupt after. debug: A flag indicating whether to enable debug mode. name: The name to use for the compiled graph. Returns: CompiledStateGraph: The compiled `StateGraph`. *)rr__root__builderschema_to_mapperryrnrpinput_channels stream_modeupdatesoutput_channelsstream_channels checkpointerinterrupt_before_nodesinterrupt_after_nodes auto_validateFrrrr LangGraphNr)rrrrr{rrCrprXrTrPrQrSryrqr9r3rz attach_nodernrm attach_edgersro attach_branch)rr rrrrrrrvalr r rurirrrrors r`compilezStateGraph.compile7sD,1r)/R #c)&6%<!"W  4<< 2 2349dll4+=+=>>  !% T-?-? @ F F HC', 4==!Q&:+F %)MM$7$7$9 SAQRUAV &fh&GH    ..   --,,~d&7&78  ! " , , & $4 #2! " # $% &' () *$+ 0 UD)))+ ,IC  d + ,** -JE3   , - -- .KFC   - . $}}224  +    " *.CG+/@D -   (  '  A ) > +    " *.!CG+/@D  0   (   A ) > +    :> *.CG+/@D 3 7   (  ' A ) > +    &:>U *.04CG+/@DU3U7U  U ( U.UAU)U>U+U Un4x<@ 0070 9 0 0d- -  -^ )$<@ A7A 9 A  A0 '/f&*g##'"&3726g#"g# g#  g# 1 g#0g#g#g# ?g#rbrWceZdZUded<ded< dfd Z d ddZ d ddZddZdd Zd d  dd Z dfd Z xZ S)rX-StateGraph[StateT, ContextT, InputT, OutputT]r,dict[type[Any], Callable[[Any], Any] | None]rc @t|di|||_||_yNr)superrrr)rrrrrfs r`rzCompiledStateGraph.__init__s$ "6" 0rbct|jj|jj|jj|j dS)NInputtyprrrpr)_get_json_schemarrzrrrprrconfigs r`get_input_jsonschemaz'CompiledStateGraph.get_input_jsonschemasD  ))LL((\\**w'   rbct|jj|jj|jj|j dS)NOutputr0)r2rr{rrrprr3s r`get_output_jsonschemaz(CompiledStateGraph.get_output_jsonschemasD  **LL((\\**x(   rbc @ |tk(rZ|jj|jjj Dcgc]\}}t |s|c}} nWt |jj|jjj Dcgc]\}}| c}}z d fd t dgk(rtn tt|!|jt|jndf}|tk(r5ttgtgtt!|g|j"|<y|9|r |jn|jj$}t |jj|}t'|dk(xrd|v}||j(vr|j(|} nt+||} | |j(|<t,j/|} |j0rt3t4nt7t4d|j| <t| g|rdn|| t!|g|j8|j:|j<|j> |j"|<yt@cc}}wcc}}w) Nc.|yt|tr*|jDcgc]\}}|vs ||fc}}St|trH|jtj k(ry|j Dcgc]\}}|vs ||fc}}St|ttfr|rtd|Dr}g}|D]t}t|trG|jtj k(r1|jfd|j DZ|j|xsdv|St|x}rt|r t|Std|tj }t#|cc}}wcc}}w)Nc3<K|]}t|tywrrZrMris r`rzGCompiledStateGraph.attach_node.._get_updates..s>1 1g.>c36K|]\}}|vs ||fywrr)rkv output_keyss r`rzGCompiledStateGraph.attach_node.._get_updates..s%''+q![HXQF's  rzExpected dict, got )message error_code)rZrrrMgraphPARENT_update_as_tupleslistranyextendr[r)r+r>r;INVALID_GRAPH_NODE_RETURN_VALUEr<) rrArBrr>tmsg _get_updatesrCs r`rOz4CompiledStateGraph.attach_node.._get_updatessu}E4(+0;;=M41aA'>'@#q!ADTQF54-0>>>13>A!!W-77gnn4$'/0/B/B/D' |A'<"=>E{"!"(A!(D+E;??*1%9(HH)--=Ns F F  F Fr)mapper)rPstatic)tagstriggersrpwritersrF)guard)rSrprPrTrrrbound)rzNone | dict | Anyr Sequence[tuple[str, Any]] | None)!r9rrrrzrrCrIrprqrI _get_root_control_branchr_control_staticrFr:rGrnrwrr _pick_mapper_CHANNEL_BRANCH_TOformatrr5rr3rrrrunnabler) rrrirArB write_entriesrzris_single_inputrPbranch_channelrOrCs @@r`rzCompiledStateGraph.attach_nodesW %<!LL001J1JKQQSAq'*K t||445"ll2288:9a9K$ .$$ . -$ .P #$/J<$?y\  #&# (='tyy1   Q  %<( \%m45 DJJsO  044,,$,,:S:SL!$,,"6"6|"DEN!.1Q6W:;WOt444..|<%nlC6<%%l3/66s;N::%S)#Cu5 MM. ) )()(7*^%m45!..!..mm DJJsO G 9s J+ Jc t|trZ|tk7rP|j|jj t ttj|dfyy|tk7rddj|d|}|jj|jr'ttt||j|<n&t!tt||j|<|j|j"j ||D]>}|j|jj t t||f@yy)Nzjoin:+:)rZrr8rnrTappendrGrHr\r]rrrr7rrpr6rS)rrr channel_namers r`rzCompiledStateGraph.attach_edge.s+ fc "cz 6"**11 *+=+D+DS+I4PR CZ"388F#3"4AcU;L||!!#&,,.JV/ l+/@S[.Q l+ JJsO $ $ + +L 9  5!))00 "3L%"H!JK rbT) with_readercX d dd}|r|jxsQ||jjvr#|jj|jn|jj}t |jj |}||j vr|j |}nt||}||j |<ttj|dgk(r|dn|d|} nd} |j|jj|j|| y)Nc|Dcgc]J}|rn |tk7r.get_writesKsv! "DS &a.&#X+=+D+DQ+G  F  M sAArrT)selectfreshrP)F)rjzSequence[str | Send]rQrtrz"Sequence[ChannelWriteEntry | Send])rzrrnrwrIrrrr[r rEdo_readrTrerun) rrrrrgrmr_rprPreaders r`rz CompiledStateGraph.attach_branchHs';@ ) 37  / $ ((DLL... ""5)66\\..  DLL0089H.....v6%h706%%f-=D##&.:,&>x{H >FF 5!!((J)GHrbct|||d}|d}|d}|sy|ddk\ryt|D]}|jds|j dd }||j vr8d |}||vrt |||j|n|j|}|j|i|jtifD]4} || vs| j|} || vrt | | || |<0| | |<6||vr||vr|j|||<|||<t|D]}|jd s|jddk(s+|j dd }||j vrNd |}||vrt |||j|n|j|}|j|i|jtifD]4} || vs| j|} || vrt | | || |<0| | |<6||vr||vr|j|||<|||<t|j j|sgtt} |jjD]-\} } | t k7s| t"k7s| | j%| /t|D]}|t k(r||j vs|j|}|j|t&}| |D]} d | }||vrt |||n|}|j| i|jtifD]4} || vs| j|} || vrt | | || |<0| | |<6||vr |t&ur|||<|||<t|vs|tj|t&yy) z+Migrate a checkpoint to new channel layout.channel_valueschannel_versions versions_seenNrBzstart:rdrz branch:to:zbranch:)r-_migrate_checkpointrI startswithsplitrnmaxpoprr%countr isdisjointrrrmr9r8rer/)r checkpointrversionsseenrArinew_knew_vssssource_to_targetrrrBcrfs r`ryz&CompiledStateGraph._migrate_checkpointys #J/,-01/*  c?a  h (A||H%wws|Atzz)$TF+(a9!a  88D"-txx 2/FG*BBwFF1I B;(+Ar%y(9BuI()BuI *&1;$*JJqMF5M"'3 (8h (A||I&1773<1+<wws|B'tzz)$TF+(a9!a  88D"-txx 2/FG*BBwFF1I B;(+Ar%y(9BuI()BuI *&1;$*JJqMF5M"'3 (64::))(3*40 "ll00 8 sE>cSj$U+2237 8(^ 8: ? QA 1g.A/20",SE 2;@H;LHUOQ 7RS#'88C#4dhhy"6M"N2B Bw$&FF1I#(B;03Ar%y0ABuI01BuI 2!.1G3C,-F5M*/!0$!D(Y++Aw73 8 4rb)rr)rr*rrrrr)r4zRunnableConfig | Nonerdict[str, Any])rrriz#StateNodeSpec[Any, ContextT] | Nonerr)rzstr | Sequence[str]rrrr) rrrrrr?rgrtrr)rrrr) rdr#r$r&rr5r8rrrry __classcell__)rfs@r`rXrXs;:BB 1? 1G 1  1  1/3 +  /3 +  eN6QU/I/I #/I-7/IIM/I /Ibg8g8rbrXch|dgk(ryt|rt|trytt|S)Nr)r issubclassrr _coerce_state) state_keysr_s r`r[r[s1j\!v:fd3 =& ))rbc|di|Sr,r)r_rs r`rrs ?E?rbct|tr t|ffSg}t|tr|j |n?t|t t fr)|D]$}t|ts|j |&g}|D]}|jtjk(r t|t|jttfr |jgn |j}|D]k}t|tr|j t|f+t|ts<|tk7sF|j tj|dfm|Sr)rZrOr(rMrerIrrFrGr=gotorr8r\r])valuecommandscmdrcommand goto_targetsgos r`rYrYs$%   H%! ED%= ) %C#w'$ %"$CB ==GNN *( ()c{CW\\N  BB"d# E2;'B$s .55b94@A  BB Jrbc"t|trD|jDcgc](\}}|tk(r|ntj |d|f*c}}S|Dcgc]%}|tk(r|ntj |ddf'c}Scc}}wcc}wr)rZrrr8r\r])rrAlabeles r`rZrZs$!JJL 5s(Q 2 9 9! |jtjk(r1|j|j Q|jd|fe|S|d|fgSy)Nrc3<K|]}t|tywrr<r=s r`rz_get_root..$s61 1g&6r?r) rZrMrFrGrHrIrrJrKre)rrr>s r`rXrXs%! ;;'.. (&&((54-(  66 6)+ 0A!W%77gnn,q2245 A/  0  U#$$ rbc t|dsdtd|diiifSt|d}|jDcic]\}}|dk7r |t||}}}|jDcic]\}}t |t s||c}}|jDcic]\}}t |s||c}}|fScc}}wcc}}wcc}}w)Nr&rFrT)include_extras __slots__)r _get_channelrrrZr1rC)r_rrr1all_keysrArBs r`rr3s 6, - j&N O     tq.AAB   JBsC2C  C &C:Ccyrrr annotationrs r`rrJsrbTrcyrrrs r`rrPs&)rbc*t|dr'|jttfvr|jd}t ||x}r|r|St d|dt|x}r ||_|St|x}r ||_|St|}||_|S)N __origin__rzThis z not allowed in this position) rrr!r __args___is_field_managed_valuer_is_field_channelr_is_field_binopr4)rrrmanagerrfallbacks r`rrVsz<(Z-B-BG. ((+ )$ ;;w; NuZL0MNO O%j1 1 1 #J/ / / #J/HHL Orbct|drk|j}|D]Z}t|tr|cSt |s#t |ts4|t|dr|j cS|cSy)N __metadata__r)rrrZr1r rr)r1metaitems r`rrpsnsN# SD$ , :dK#@gc<.HCNNRRcRR  S rbc2t|dr|j}t|dk\rqt|drct |d}t |j j}td|Ddk(rt||dStd|y)Nrrrxc3dK|](}|j|j|jfv*ywr)kindPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORD)rrks r`rz"_is_field_binop..s2FFq00!2I2IJJs.0r~z5Invalid reducer signature. Expected (a, b) -> c. Got ) rrrcallabler rIrrsumr2r)r1rsigparamss r`rr~ssN# t9>htBx0DH%C#..//12F#  /sDH== KC5Q rbct|dr<|j}t|dk\r"t|dxs|d}t |r|St| t |x}r|dx}r t ||Sy)Nrrrxr)rrrrrCrr)rr1r decorationargs inner_types r`rrssN# t9>#DH-9bJ +!! 3#c] "T "7 "Z "&tZ88 rbc >t|r t|tr|jSt |rt |j St||j}t|dk(r5|ddk(r-t|||djdfjSt|||Dcic]C}||vr=t||tr*|||jt|||j|fEc}jScc}w)Nrrr)root)field_definitions)r rrmodel_json_schemar$r json_schemarIrrr, UpdateTyperZr1r*)r1rrrprrrAs r`r2r2s$ s| 3 2$$&& c 3++--GCL%%'( t9>d1g3tAw'22D9 ! "  %S\ #H}HQK)M  ..- ! ( 6 6 #   #  !! " #slanggraph.graph._branchr?langgraph.graph._noder@rAlanggraph.managed.baserBrClanggraph.pregelrDlanggraph.pregel._readrErFlanggraph.pregel._writerGrHrIlanggraph.typesrJrKrLrMrNrOlanggraph.typingrPrQrRrSrTlanggraph.warningsrUrV__all__ getLoggerrdrr\rarjrWrXr[rrYrZrXrrrrrr2rrbr`rsm" #CC<<&   >*0*+OO  7<LL/<=I76 /:$: KJW .   8 $# @o #67:;o #d8 68VW ,- FHfg -.8D **'0* *:  *  *  %. O.  2@   BF) ))2?)#) ) :> 26#4 *&"" "" """"  ""  ""rb