o i> @sdZddlmZddlZddlmZmZddlmZm Z m Z ddl m Z m Z ddlmZddlmZmZmZmZmZmZmZdd lmZmZmZdd lmZmZdd lm Z m!Z!dd l"m#Z#m$Z$m%Z%dd l&m'Z'ddl(m)Z)m*Z*m+Z+m,Z,m-Z-ddl.m/Z/m0Z0m1Z1ddl2m3Z3ddl4m5Z5m6Z6m7Z7ddl8m9Z9m:Z:m;Z;mZ>m?Z?ddl@mAZAmBZBmCZCmDZDmEZEmFZFmGZGddlHmIZImJZJmKZKmLZLmMZMmNZNddlOmPZPmQZQmRZRddlSmTZTmUZUddlVmWZWmXZXedddZYedddZZedddZ[edddZ\edddZ]ed eWeeefdd!Z^ed"ddZ_ed#ddZ`ed$ddZaed%ddZbe d&d'Gd(d)d)eeYeZe`eafZcdOd0d1ZddPd4d5ZedPd6d7ZfdQd;d<ZgdRd?d@ZhdSdAdBZidTdDdEZjdUdIdJZkdVdMdNZldS)WzGraph builder for constructing executable graph definitions. This module provides the GraphBuilder class and related utilities for constructing typed, executable graph definitions with steps, joins, decisions, and edge routing. ) annotationsN)Counter defaultdict) AsyncIterableCallableIterable) dataclassreplace)NoneType)AnyGenericLiteralcast get_originget_type_hintsoverload)Never TypeAliasTypeTypeVar)_utils exceptions)UNSETUnset)DecisionDecisionBranchDecisionBranchBuilder)Graph)ForkIDJoinIDNodeIDgenerate_placeholder_node_idreplace_placeholder_id)JoinJoinNodeReducerFunction)build_mermaid_graph)EndNodeFork StartNode)AnyDestinationNodeAnyNodeDestinationNode SourceNode) ParentForkParentForkFinder)BroadcastMarkerDestinationMarkerEdgePathEdgePathBuilder MapMarkerPath PathBuilder)NodeStepStep StepContext StepFunctionStepNodeStreamFunction)TypeOrTypeExpressionget_callable_nameunpack_type_expression)GraphBuildingErrorGraphValidationError)BaseNodeEndStateTT)infer_varianceDepsTInputTOutputTSourceT SourceNodeT)boundrD SourceOutputT GraphInputT GraphOutputTTF)initc@sReZdZUdZded< ded< ded< ded < d ed < d ed < ded< ded< ded< edeeee fe fdZ ede eee fe fdZ deeeedddddZedddZedd!d"Zeddd#dd'd(Zeddd#dd,d(Z dddd#dd/d(Zeddd#dd1d2Zeddd#dd5d2Ze dddd#dd8d2Z dddd#dd9d2Zeddd:d;ddDdEZeddd:d;ddHdEZeeddd:dIddLdEZddPdQZddRddWdXZdddddYddbdcZddgdhZdddiddldmZddnddsdtZddnddwdxZdd{d|ZdddZ dddZ!ddddZ"dS) GraphBuilderaA builder for constructing executable graph definitions. GraphBuilder provides a fluent interface for defining nodes, edges, and routing in a graph workflow. It supports typed state, dependencies, and input/output validation. Type Parameters: StateT: The type of the graph state DepsT: The type of the dependencies GraphInputT: The type of the graph input data GraphOutputT: The type of the graph output data str | NonenameTypeOrTypeExpression[StateT] state_typeTypeOrTypeExpression[DepsT] deps_type!TypeOrTypeExpression[GraphInputT] input_type"TypeOrTypeExpression[GraphOutputT] output_typeboolauto_instrumentdict[NodeID, AnyNode]_nodesdict[NodeID, list[Path]]_edges_by_sourceint_decision_indexSource) type_params DestinationNT)rRrTrVrXrZr\cCsV||_||_||_||_||_||_i|_tt|_ d|_ t t |_ tt|_dS)aInitialize a graph builder. Args: name: Optional name for the graph, if not provided the name will be inferred from the calling frame on the first call to a graph method. state_type: The type of the graph state deps_type: The type of the dependencies input_type: The type of the graph input data output_type: The type of the graph output data auto_instrument: Whether to automatically create instrumentation spans N)rRrTrVrXrZr\r^rlistr`rbr(rL _start_noder&rM _end_node)selfrRrTrVrXrZr\rkg/var/www/html/karishye-ai-python/venv/lib/python3.10/site-packages/pydantic_graph/beta/graph_builder.py__init__ms  zGraphBuilder.__init__returnStartNode[GraphInputT]cC|jS)z}Get the start node for the graph. Returns: The start node that receives the initial graph input )rhrjrkrkrl start_nodezGraphBuilder.start_nodeEndNode[GraphOutputT]cCrp)zxGet the end node for the graph. Returns: The end node that produces the final graph output )rirqrkrkrlend_noderszGraphBuilder.end_node)node_idlabelrvrw^Callable[[StepFunction[StateT, DepsT, InputT, OutputT]], Step[StateT, DepsT, InputT, OutputT]]cCdSNrkrjrvrwrkrkrlstepszGraphBuilder.stepcall,StepFunction[StateT, DepsT, InputT, OutputT]$Step[StateT, DepsT, InputT, OutputT]cCryrzrkrjr}rvrwrkrkrlr|3StepFunction[StateT, DepsT, InputT, OutputT] | NoneStep[StateT, DepsT, InputT, OutputT] | Callable[[StepFunction[StateT, DepsT, InputT, OutputT]], Step[StateT, DepsT, InputT, OutputT]]csL|durd fdd }|Spt|tttttft|d}|S) aCreate a step from a step function. This method can be used as a decorator or called directly to create a step node from an async function. Args: call: The step function to wrap node_id: Optional ID for the node label: Optional human-readable label Returns: Either a Step instance or a decorator function Nfuncr~rnrcj|dSNr}rvrwr|rrwrvrjrkrl decoratorz$GraphBuilder.step..decorator)idr}rw)rr~rnr)r=r7rCrErFrGr)rjr}rvrwrr|rkrrlr|s  oCallable[[StreamFunction[StateT, DepsT, InputT, OutputT]], Step[StateT, DepsT, InputT, AsyncIterable[OutputT]]]cCryrzrkr{rkrkrlstreamszGraphBuilder.stream.StreamFunction[StateT, DepsT, InputT, OutputT]3Step[StateT, DepsT, InputT, AsyncIterable[OutputT]]cCryrzrkrrkrkrlrr5StreamFunction[StateT, DepsT, InputT, OutputT] | NoneStep[StateT, DepsT, InputT, AsyncIterable[OutputT]] | Callable[[StreamFunction[StateT, DepsT, InputT, OutputT]], Step[StateT, DepsT, InputT, AsyncIterable[OutputT]]]cCryrzrkrrkrkrlrs cs<durd fdd }|Sdfd d }j|d S)aCreate a step from an async iterator (which functions like a "stream"). This method can be used as a decorator or called directly to create a step node from an async function. Args: call: The step function to wrap node_id: Optional ID for the node label: Optional human-readable label Returns: Either a Step instance or a decorator function Nrrrnrcrr)rrrrkrlrrz&GraphBuilder.stream..decoratorctx"StepContext[StateT, DepsT, InputT]cs |Srzrk)r)r}rkrlwrappersz$GraphBuilder.stream..wrapperr)rrrnr)rrr)rjr}rvrwrrrk)r}rwrvrjrlrs farthest)rvparent_fork_idpreferred_parent_forkreducer/ReducerFunction[StateT, DepsT, InputT, OutputT]initialrGrrLiteral['farthest', 'closest']$Join[StateT, DepsT, InputT, OutputT]cCryrzrk)rjrrrvrrrkrkrljoin! zGraphBuilder.joininitial_factoryCallable[[], OutputT]cCryrzrk)rjrrrvrrrkrkrlr+r)rrrvrrOutputT | UnsetCallable[[], OutputT] | Unsetcsj|tur fdd}tttttftt|ptt ||t t gtf||dur0t ||dSd|dS)NcsSrzrkrkrrkrlAsz#GraphBuilder.join..)rrrrr) rr"rCrErFrGrrr r=rrr)rjrrrrvrrrkrrlr6s edgesEdgePath[StateT, DepsT]Nonec sd fdd dfdd ttg|D]&}|jD]}|j|j|jq!|jD]}|q6|jqD];}t |t rQt |t rRqEt t}t|j|d d }z|d }Wn typYqEw||}|d ur|qEd S)zAdd one or more edge paths to the graph. This method processes edge paths and automatically creates any necessary fork nodes for broadcasts and maps. Args: *edges: The edge paths to add to the graph pr4cs|jD]G}t|tr,tttf|jddd}||jD] }tg|jdqqt|t rDtttf|jd|j d}|qt|t rJ qdS)zvProcess a path and create necessary fork nodes. Args: p: The path to process FNris_mapdownstream_join_iditemsT) r isinstancer/r'r fork_id _insert_nodepathsr4r3rr0)ritemnew_nodepath) _handle_pathrjrkrlrVs       z&GraphBuilder.add.._handle_pathdr)csnt|vrdSt|||t|tr3|jD]}|j|jD]}|q+q!dSdSrz) raddappendrrrbranchesr destinations)rbranchd2_handle_destination_noderdestination_idsrrjrkrlrhs        z2GraphBuilder.add.._handle_destination_nodeTlocalnsinclude_extrasrnN)rr4)rr))setrasourcesrr`rrrrrr7r6rget_parent_namespaceinspect currentframerr}KeyError_edge_from_return_hintr) rjredge source_nodedestination_node destinationparent_namespace type_hints return_hintrkrrlrLs4           zGraphBuilder.add)rwsource Source[T]rDestination[T]cCs0||}|dur||}|||dS)zAdd a simple edge between two nodes. Args: source: The source node destination: The destination node label: Optional label for the edge N) edge_fromrwrto)rjrrrwbuilderrkrkrladd_edges  zGraphBuilder.add_edge) pre_map_labelpost_map_labelrrSource[Iterable[T]]map_torrr ForkID | Noner JoinID | NonecCsP||}|dur||}|j||d}|dur||}|||dS)axAdd an edge that maps iterable data across parallel paths. Args: source: The source node that produces iterable data map_to: The destination node that receives individual items pre_map_label: Optional label before the map operation post_map_label: Optional label after the map operation fork_id: Optional ID for the fork node produced for this map operation downstream_join_id: Optional ID of a join node that will always be downstream of this map. Specifying this ensures correct handling if you try to map an empty iterable. N)rr)rrwmaprr)rjrrrrrrrrkrkrladd_mapping_edges   zGraphBuilder.add_mapping_edgerSource[SourceOutputT]-EdgePathBuilder[StateT, DepsT, SourceOutputT]cGsttttf|tgddS)zCreate an edge path builder starting from the given source nodes. Args: *sources: The source nodes to start the edge path from Returns: An EdgePathBuilder for constructing the complete edge path  working_items)r path_builder)r2rCrErKr5)rjrrkrkrlrs zGraphBuilder.edge_from)notervrDecision[StateT, DepsT, Never]cCstt|ptdg|dS)aCreate a new decision node. Args: note: Optional note to describe the decision logic node_id: Optional ID for the node produced for this decision logic Returns: A new Decision node with no branches decisionrrr)rrr )rjrrvrkrkrlrs zGraphBuilder.decision)matchesTypeOrTypeExpression[SourceT]rCallable[[Any], bool] | None=DecisionBranchBuilder[StateT, DepsT, SourceT, SourceT, Never]cCsHttd}ttttf|gdd}ttttfgd}t||||dS)aCreate a decision branch matcher. Args: source: The type or type expression to match against matches: Optional custom matching function Returns: A DecisionBranchBuilder for constructing the branch match_decisionNrr)rrrr) rr rrCrErr5rHr)rjrrrvrnew_path_builderrkrkrlmatchs zGraphBuilder.matchtype[SourceNodeT]DecisionBranch[SourceNodeT]cCs,t|}tt|jgd}t||||gdS)a~Create a decision branch for BaseNode subclasses. This is similar to match() but specifically designed for matching against BaseNode types from the v1 system. Args: source: The BaseNode subclass to match against matches: Optional custom matching function Returns: A DecisionBranch for the BaseNode type r)rrrr)r6r4r0rr)rjrrnoderrkrkrl match_nodeszGraphBuilder.match_node node_type+type[BaseNode[StateT, DepsT, GraphOutputT]]c Cstt}t|j|dd}z|d}Wnty+}z td|d|d}~wwt |}| ||}|sAtd|d|S)aCreate an edge path from a BaseNode class. This method integrates v1-style BaseNode classes into the v2 graph system by analyzing their type hints and creating appropriate edges. Args: node_type: The BaseNode subclass to integrate Returns: An EdgePath representing the node and its connections Raises: GraphSetupError: If the node type is missing required type hints TrrnNode z2 is missing a return type hint on its `run` methodN) rrrrrrunrrGraphSetupErrorr6r)rjrrrrerrrkrkrlrs"   zGraphBuilder.noderr*cCsr|j|j}|dur||j|j<dSt|tr%t|tr%|j|jur%dS||ur7td|jd|d|dS)zInsert a node into the graph, checking for ID conflicts. Args: node: The node to insert Raises: ValueError: If a different node with the same ID already exists Nz%All nodes must have unique node IDs. z was the ID for z and )r^getrrr6rr?)rjrexistingrkrkrlr#s  zGraphBuilder._insert_nodeSourceNode[StateT, DepsT, Any]rTypeOrTypeExpression[Any]EdgePath[StateT, DepsT] | Nonec Csg}t|}|D]}t|\}}t|p|}|tur#||jq |tur0t d|d|t ur\t t t tttfdBtdd|Dd}|durVt d|d||q |turt tt tttfdBtdd|Dd} | durt d|d|| q t|rt|tr|t|q t|t|krdS||} t|d kr| |d S|} |D] } | |t| } q| | S) aCreate edges from a return type hint. This method analyzes return type hints from step functions or node methods to automatically create appropriate edges in the graph. Args: node: The source node return_hint: The return type hint to analyze Returns: An EdgePath if edges can be inferred, None otherwise Raises: GraphSetupError: If the return type hint is invalid or incomplete rz return type hint includes a plain `BaseNode`. Edge inference requires each possible returned `BaseNode` subclass to be listed explicitly.Ncs|] }t|tr|VqdSrz)rr7.0arkrkrl Wz6GraphBuilder._edge_from_return_hint..z return type hint includes a `StepNode` without a `Step` annotation. When returning `my_step.as_node()`, use `Annotated[StepNode[StateT, DepsT], my_step]` as the return type hint.csrrzrr"rrkrkrlrbrz return type hint includes a `JoinNode` without a `Join` annotation. When returning `my_join.as_node()`, use `Annotated[JoinNode[StateT, DepsT], my_join]` as the return type hint.rfr)rget_union_argsunpack_annotatedrrBrrurArrr:rr7rCrEr nextr#r"risclass issubclassr6lenrrrrrr ) rjrrr union_args return_typerreturn_type_originr|rrrrrkrkrlr6sV          z#GraphBuilder._edge_from_return_hintvalidate_graph_structure/Graph[StateT, DepsT, GraphInputT, GraphOutputT]c Cs|j}|j}t||\}}t||\}}t||\}}|r"t||t||}t||}tt t t t f|j t|jt|jt|jt|j|||||jd S)a^Build the final executable graph from the accumulated nodes and edges. This method performs validation, normalization, and analysis of the graph structure to create a complete, executable graph instance. Args: validate_graph_structure: whether to perform validation of the graph structure See the docstring of _validate_graph_structure below for more details. Returns: A complete Graph instance ready for execution Raises: ValueError: If the graph structure is invalid (e.g., join without parent fork) ) rRrTrVrXrZnodesedges_by_source parent_forksintermediate_join_nodesr\)r^r`_replace_placeholder_node_ids_flatten_paths_normalize_forks_validate_graph_structure_collect_dominating_forks _compute_intermediate_join_nodesrrCrErLrMrRr>rTrVrXrZr\)rjrrrrrrkrkrlbuild|s*   zGraphBuilder.build) rRrQrTrSrVrUrXrWrZrYr\r[)rnro)rnrt)rvrQrwrQrnrx)r}r~rvrQrwrQrnrrz)r}rrvrQrwrQrnr)rvrQrwrQrnr)r}rrvrQrwrQrnr)r}rrvrQrwrQrnr) rrrrGrvrQrrQrrrnr) rrrrrvrQrrQrrrnr)rrrrrrrvrQrrQrrrnr)rrrnr)rrrrrwrQrnr)rrrrrrQrrQrrrrrnr)rrrnr)rrQrvrQrnr)rrrrrnr)rrrrrnr)rrrnr)rr*rnr)rrrrrnr)T)rr[rnr)#__name__ __module__ __qualname____doc____annotations__rr,rCrErGrcr+rFrer rmpropertyrrrurr|rrrrrrrrrrrrrrrkrkrkrlrP@s  %   &)  B    $ FrPrr]rr_rnrcs d}tdfdd }|D] }|D]}||qq|D]}t|tr2|jD]}||jq*q |tjg}|sBt d|t jvrMt d |g} | D]+\} }t|t r]qS| |voht || d k} t|trw| pvt |jd k} | s~| | qS| rt d | d |tjhtjg} | r| } || gD]}|j D]}t|tr|jvr|j| |jqq|| }t|tr|jD]}|jj D]}t|tr|jvr|j| |jqq| sfd d|D}|rt d|d |dS)aValidate the graph structure for common issues. This function raises an error if any of the following criteria are not met: 1. There are edges from the start node 2. There are edges to the end node 3. No non-End node is a dead end (no outgoing edges) 4. The end node is reachable from the start node 5. All nodes are reachable from the start node Note 1: Under some circumstances it may be reasonable to build a graph that violates one or more of the above conditions. We may eventually add support for more granular control over validation, but today, if you want to build a graph that violates any of these assumptions you need to pass `validate_graph_structure=False` to the call to `GraphBuilder.build`. Note 2: Some of the earlier items in the above list are redundant with the later items. I've included the earlier items in the list as a reminder to ourselves if/when we add more granular validation because you might want to check the earlier items but not the later items, as described in Note 1. Args: nodes: The nodes in the graph edges_by_source: The edges by source node Raises: GraphBuildingError: If any of the aforementioned structural issues are found. z If this is intentional, you can suppress this error by passing `validate_graph_structure=False` to the call to `GraphBuilder.build`.rr4rnrcs&|jD] }t|tr|jqdSrz)rrr0rdestination_id)rr)all_destinationsrkrl_collect_destinations_from_paths   zB_validate_graph_structure.._collect_destinations_from_pathz+The graph has no edges from the start node.z'The graph has no edges to the end node.rz,The following nodes have no outgoing edges: .csg|]}|vr|qSrkrk)rrv) reachablerkrl sz-_validate_graph_structure..z;The following nodes are not reachable from the start node: N)rr4rnr)rvaluesrrrrrr(rr@r&rr rpopr0r$r)rrhow_to_suppressr&rrrr start_edgesdead_end_nodesrv has_edgesto_visit current_idr current_nodeunreachable_nodesrk)r%r(rlrst                         rr6tuple[dict[NodeID, AnyNode], dict[NodeID, list[Path]]]c s}tt}g}dfdd }|D]}t|tr1|jD]}||j\}} ||_|| qq| D]\} } | D] } | | | fq._split_at_first_fork..) enumeraterrr3rr4rgr0r/r)riupstream downstreamrr7rl_split_at_first_forks " "z,_flatten_paths.._split_at_first_fork)rr4rnr5) copyrrgr*rrrrextendrrr+dict) rr new_nodes new_edgespaths_to_handler>rrr; downstreams source_idedges_from_sourcerrkr=rlrs,        rc Cs|}i}g}|D]N\}}||||}t|tr&|js&|||<q t|dkr1|||<q tttftt |j dddd}|||j <t t |j gdg||<|||j <q ||fS)aNormalize the graph structure so only broadcast forks have multiple outgoing edges. This function ensures that any node with multiple outgoing edges is converted to use an explicit broadcast fork, simplifying the graph execution model. Args: nodes: The nodes in the graph edges: The edges by source node Returns: A tuple of normalized nodes and edges rf_broadcast_forkFNrr) r?rr@rr'rr r rrrr4r0) rrrBrCrDrFrGrnew_forkrkrkrlr=s"  &  r graph_nodesgraph_edges_by_source dict[JoinID, ParentFork[NodeID]]cs"t|}tjh}ttt|}|D];}|}||}t|tr&||jdfdd }t|t r?|j D]} || j |q5q||gD]} || |qEqt |||d} dd | D} i} | D]+}| j|j|j|jd kd }|d urt||}td |d|jd|| |j<qc| S)aFind the dominating fork for each join node in the graph. This function analyzes the graph structure to find the parent fork that dominates each join node, which is necessary for proper synchronization during graph execution. Args: graph_nodes: All nodes in the graph graph_edges_by_source: Edges organized by source node Returns: A mapping from join IDs to their parent fork information Raises: ValueError: If any join node lacks a dominating fork rr4last_source_idrcs0|jD]}t|tr||jdSqdS)zProcess a path and collect edges and fork information. Args: path: The path to process last_source_id: The current source node ID N)rrr0rr$)rrMrrrkrlrs  z/_collect_dominating_forks.._handle_path)r start_idsfork_idsrcSsg|] }t|tr|qSrkr)rrrkrkrlr)sz-_collect_dominating_forks..closest)rprefer_closestNaA node in the graph is missing a dominating fork. For every Join J in the graph, there must be a Fork F between the StartNode and J satisfying: * Every path from the StartNode to J passes through F * There are no cycles in the graph including J that don't pass through F. In this case, F is called a "dominating fork" for J. This is used to determine when all tasks upstream of this Join are complete and we can proceed with execution. Mermaid diagram: z Join z4 in this graph has no dominating fork in this graph.)rr4rMr)rr(rrrgrrr'rrrrr.r*find_parent_forkrrr%renderr?)rJrKrrOrPrFworking_source_idrrrrfinderjoinsdominating_forksrdominating_forkrendered_mermaid_graphrkrNrlrcsL        rrdict[JoinID, set[JoinID]]cCsZi}|D]$\}}tt}|jD]}||}t|tr%|t|q|||<q|S)agCompute which joins have other joins as intermediate nodes. A join J1 is an intermediate node of join J2 if J1 appears in J2's intermediate_nodes (as computed relative to J2's parent fork). This information is used to determine: 1. Which joins are "final" (have no other joins in their intermediate_nodes) 2. When selecting which reducer to proceed with when there are no active tasks Args: nodes: All nodes in the graph parent_forks: Parent fork information for each join Returns: A mapping from each join to the set of joins that are intermediate to it )rrrintermediate_nodesrrr"r)rrrjoin_id parent_forkintermediate_joinsintermediate_node_idintermediate_noderkrkrlrs     rcs<t|fdd|D}fdd|D}||fS)Ncs$i|]\}}||t|qSrk)r_update_node_with_id_remapping)rrRrnode_id_remappingrkrl sz1_replace_placeholder_node_ids..cs,i|]\}}||fdd|DqS)cg|]}t|qSrk_update_path_with_id_remappingr6rcrkrlr)r8z<_replace_placeholder_node_ids...)r)rrrrcrkrlres)$_build_placeholder_node_id_remappingr)rrreplaced_nodesreplaced_edges_by_sourcerkrcrlrs  rdict[NodeID, NodeID]cCshtt}i}|D]&}t|}||krq ||d||<}t|dkr,|d|n|||<q |S)acThe determinism of the generated remapping here is dependent on the determinism of the ordering of the `nodes` dict. Note: If we want to generate more interesting names, we could try to make use of information about the edges into/out of the relevant nodes. I'm not sure if there's a good use case for that though so I didn't bother for now. rf_)rstrkeysr!r)rcounter remappingrvreplaced_node_idcountrkrkrlris  $rirr*rdcst|tr|j|j|_|St|tr"t|j|j|_|St|trDt|j|j|_|jdurBt|j|j|_|St|t r]|j|j|_fdd|j D|_ |S)Ncs g|] }t|t|jdqS))r)r rhr)rrrcrkrlr)sz2_update_node_with_id_remapping..) rr7rrr"rr'rrrr)rrdrkrcrlrbs"      rbrr4cs|jD]M}t|tr&|j}|durt|||_t|j|j|_qt|trBt|j|j|_fdd|j D|_ qt|t rP|j |j |_ q|S)Ncrfrkrgr6rcrkrlr)r8z2_update_path_with_id_remapping..) rrr3rrrrrr/rr0r$)rrdrrrkrcrlrhs    rh)rr]rr_rnr)rr]rr_rnr4)rJr]rKr_rnrL)rr]rrLrnr[)rr]rr_)rr]rnrl)rr*rdrlrnr*)rr4rdrlrnr4)mr! __future__rr collectionsrrcollections.abcrrr dataclassesrr typesr typingr r r rrrrtyping_extensionsrrrpydantic_graphrrpydantic_graph._utilsrrpydantic_graph.beta.decisionrrrpydantic_graph.beta.graphrpydantic_graph.beta.id_typesrrrr r!pydantic_graph.beta.joinr"r#r$pydantic_graph.beta.mermaidr%pydantic_graph.beta.noder&r'r(pydantic_graph.beta.node_typesr)r*r+r, pydantic_graph.beta.parent_forksr-r.pydantic_graph.beta.pathsr/r0r1r2r3r4r5pydantic_graph.beta.stepr6r7r8r9r:r;pydantic_graph.beta.utilr<r=r>pydantic_graph.exceptionsr?r@pydantic_graph.nodesrArBrCrErFrGrHrIrKrLrMrNrPrrrrrrrirbrhrkrkrkrlsb  $  $           h n * & V "