o i @sdZddlmZddlZddlZddlmZmZm Z m Z m Z ddl m Z mZmZmZmZddlmZmZddlmZmZmZmZmZmZmZmZmZddlm Z m!Z!m"Z"dd l#m$Z$dd l%m&Z&m'Z'dd l(m)Z)m*Z*dd l+m,Z,dd l-m.Z.m/Z/m0Z0m1Z1ddl2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAddlBmCZCmDZDmEZEddlFmGZGddlHmIZIddlJmKZKmLZLmMZMmNZNmOZOmPZPddlQmRZRmSZSmTZTmUZUddlVmWZWddlXmYZYmZZZej[dkrddl\m]Z]ne]Z]erddl^m_Z_e)dddZ` e)dddZa e)dddZb e)d ddZc ed!d"Gd#d$d$eecZdeGd%d&d&Zeed!d'Gd(d)d)ee`eaebecfZfeGd*d+d+ZgGd,d-d-ee`eaecfZheGd.d/d/ZieGd0d1d1ZjeGd2d3d3ee`eaecfZkd?d8d9Zld@d;d<Zmed=d>ZndS)AaCore graph execution engine for the next version of the pydantic-graph library. This module provides the main `Graph` class and `GraphRun` execution engine that handles the orchestration of nodes, edges, and parallel execution paths in the graph-based workflow system. ) annotationsN)AsyncGenerator AsyncIterable AsyncIteratorIterableSequence)AbstractContextManagerAsyncExitStack ExitStackasynccontextmanagercontextmanager) dataclassfield) TYPE_CHECKINGAnyGenericLiteral TypeGuardcastget_args get_originoverload) CancelScopecreate_memory_object_streamcreate_task_group) TaskGroup)MemoryObjectReceiveStreamMemoryObjectSendStream)TypeVar assert_never) exceptions) AbstractSpanget_traceparentinfer_obj_name logfire_span)Decision)ForkID ForkStack ForkStackItem GraphRunIDJoinIDNodeID NodeRunIDTaskID)JoinJoinNode JoinStateReducerContext)EndNodeFork StartNode)AnyNode) ParentFork)BroadcastMarkerDestinationMarker LabelMarker MapMarkerPathTransformMarker)NodeStepStep StepContextStepNode)unpack_type_expression)BaseNodeEnd) )ExceptionGroup)StateDiagramDirectionStateTT)infer_varianceDepsTInputTOutputTFinitc@s4eZdZUdZded< d ddZed dd Zd S) EndMarkera A marker indicating the end of graph execution with a final value. EndMarker is used internally to signal that the graph has completed execution and carries the final output value. Type Parameters: OutputT: The type of the final output value rL_valuevaluecCs ||_dSNrPselfrQrV_/var/www/html/karishye-ai-python/venv/lib/python3.10/site-packages/pydantic_graph/beta/graph.py__init__Rs zEndMarker.__init__returncCs|jSrRrSrUrVrVrWrQVszEndMarker.valueN)rQrL)rYrL)__name__ __module__ __qualname____doc____annotations__rXpropertyrQrVrVrVrWrODs   rOc@s.eZdZUdZded< ded< ded<dS) JoinItemzAn item representing data flowing into a join operation. JoinItem carries input data from a parallel execution path to a join node, along with metadata about which execution 'fork' it originated from. r*join_idrinputsr' fork_stackN)r[r\r]r^r_rVrVrVrWra[s rareprcseZdZUdZded< ded< ded< ded < d ed < d ed < ded< ded< ded< ded< d;ddZdd.d/Z ddd0d?d5d6Z d@fd7d8 Z d@d9d:Z Z S)AGraphaA complete graph definition ready for execution. The Graph class represents a complete workflow graph with typed inputs, outputs, state, and dependencies. It contains all nodes, edges, and metadata needed for execution. Type Parameters: StateT: The type of the graph state DepsT: The type of the dependencies InputT: The type of the input data OutputT: The type of the output data str | Nonenamez type[StateT] state_typez type[DepsT] deps_typez type[InputT] input_typez type[OutputT] output_typeboolauto_instrumentzdict[NodeID, AnyNode]nodeszdict[NodeID, list[Path]]edges_by_sourcez dict[JoinID, ParentFork[NodeID]] parent_forkszdict[JoinID, set[JoinID]]intermediate_join_nodesrbr*rYParentFork[NodeID]cCs(|j|}|durtd|d|S)aGet the parent fork information for a join node. Args: join_id: The ID of the join node Returns: The parent fork information for the join Raises: RuntimeError: If the join ID is not found or has no parent fork NzNode zE is not a join node or did not have a dominating fork (this is a bug))rrget RuntimeError)rUrbresultrVrVrWget_parent_forks zGraph.get_parent_forkcCs"|jD] }||vrdSqdS)a\Check if a join is 'final' (has no downstream joins with the same parent fork). A join is non-final if it appears as an intermediate node for another join with the same parent fork. Args: join_id: The ID of the join node Returns: True if the join is final, False if it's non-final FT)rsvalues)rUrbintermediate_joinsrVrVrW is_final_joins  zGraph.is_final_joinNTstatedepsrcspan infer_namer}rHr~rJrcrKr+AbstractContextManager[AbstractSpan] | NonerrLc s|r|jdurt|dd}|dur||_|j||||dd4IdH4}d} z ||IdH}Wn$tyUt|tsAJdttt|j YWdIdHSwq'1IdHs]wYdS)a*Execute the graph and return the final output. This is the main entry point for graph execution. It runs the graph to completion and returns the final output value. Args: state: The graph state instance deps: The dependencies instance inputs: The input data for the graph span: Optional span for tracing/instrumentation infer_name: Whether to infer the graph name from the calling frame. Returns: The final output from the graph execution NdepthFr|Tz'Graph run should end with an EndMarker.) rir#iternextStopAsyncIteration isinstancerOrrLrQ) rUr}r~rcrr inferred_name graph_runeventrVrVrWruns"  z Graph.run/AsyncIterator[GraphRun[StateT, DepsT, OutputT]]c Cs|r|jdurt|dd}|dur||_t^}d}|dur,|jr+|td|d}n||}|dur7dnt|} ttt t f||||| d4IdH} | VWdIdHn1IdHsawYWddSWddS1sywYdS)aRCreate an iterator for step-by-step graph execution. This method allows for more fine-grained control over graph execution, enabling inspection of intermediate states and results. Args: state: The graph state instance deps: The dependencies instance inputs: The input data for the graph span: Optional span for tracing/instrumentation infer_name: Whether to infer the graph name from the calling frame. Yields: A GraphRun instance that can be iterated for step-by-step execution NrDrzrun graph {graph.name})graph)rr}r~rc traceparent) rir#r ro enter_contextr$r"GraphRunrHrJrL) rUr}r~rcrrrstack entered_spanrrrVrVrWrs4   *"z Graph.itertitle directionrrStateDiagramDirection | NonestrcCs$ddlm}||j|jj||dS)a Render the graph as a Mermaid diagram string. Args: title: Optional title for the diagram direction: Optional direction for the diagram layout Returns: A string containing the Mermaid diagram representation r)build_mermaid_graphr)pydantic_graph.beta.mermaidrrprqrender)rUrrrrVrVrWrs z Graph.rendercs*t}|ddd|d|dS)N )super__repr__)rU super_repr __class__rVrWr&s  zGraph.__repr__cCs|S)zReturn a Mermaid diagram representation of the graph. Returns: A string containing the Mermaid diagram of the graph )rrZrVrVrW__str__+sz Graph.__str__)rbr*rYrt)rbr*rYrn) r}rHr~rJrcrKrrrrnrYrL) r}rHr~rJrcrKrrrrnrYr)rrhrrrYrrYr)r[r\r]r^r_rxr{rr rrrr __classcell__rVrVrrWrgmsP    ).rgc@sReZdZUdZded< ded< eddZded < ed d dd Zd ed<dS) GraphTaskzA single task representing the execution of a node in the graph. GraphTask encapsulates all the information needed to execute a specific node, including its inputs and the fork context it's executing within. r+node_idrrcFrer'rdcCstttSrR)r-ruuiduuid4rVrVrVrWIszGraphTask.)default_factoryrfr-task_idN)r[r\r]r^r_rrdrrVrVrVrWr4s rc@seZdZdZd3d d ZddZd4ddZeddZe d5ddZ e d6ddZ dd d7d"dZ d8d$d%Z d9d'd(Z )d:d;d,d-Z ed9d.d/Zed|jt|j|jIdH|j|IdH|SrR)rr_unwrap_exception_groupsenter_async_contextr_iterator_contextrZrVrVrW __aenter__s zGraphRun.__aenter__exc_typerexc_valexc_tbcs|j|||IdHdSrR)r __aexit__)rUrrrrVrVrWrszGraphRun.__aexit__cCsbzdVW|jj|jj|jIdHdS|jj|jj|jIdHwrR)riter_stream_sendercloseiter_stream_receiverracloserZrVrVrWrs   zGraphRun._iterator_contextrequiredLiteral[False]rYcCdSrRrVrUrrVrVrW _traceparentzGraphRun._traceparentrcCrrRrVrZrVrVrWrrT)rrncCs|jdur |r td|jS)aBGet the trace parent for instrumentation. Args: required: Whether to raise an error if no traceparent exists Returns: The traceparent string, or None if not required and not set Raises: GraphRuntimeError: If required is True and no traceparent exists Nz&No span was created for this graph run)rr GraphRuntimeErrorrrVrVrWrs 7AsyncIterator[EndMarker[OutputT] | Sequence[GraphTask]]cCs|S)zaReturn self as an async iterator. Returns: Self for async iteration rVrZrVrVrW __aiter__szGraphRun.__aiter__(EndMarker[OutputT] | Sequence[GraphTask]cs@|jdurt|jIdH|_|jS|j|jIdH|_|jS)zyGet the next item in the async iteration. Returns: The next execution result from the graph N)ranextrasendrZrVrVrW __anext__s  zGraphRun.__anext__NrQ/EndMarker[OutputT] | Sequence[GraphTask] | Nonecs6|jdur t|IdH|dur||_t|IdHS)avAdvance the graph execution by one step. This method allows for sending a value to the iterator, which is useful for resuming iteration or overriding intermediate results. Args: value: Optional value to send to the iterator Returns: The next execution result: either an EndMarker, or sequence of GraphTasks N)rrrTrVrVrWrs  z GraphRun.nextcCs|jp|jgS)zGet the next task(s) to be executed. Returns: The next execution item, or the initial task if none is set )rrrZrVrVrW next_taskszGraphRun.next_taskOutputT | NonecCst|jtr |jjSdS)zGet the final output if the graph has completed. Returns: The output value if execution is complete, None otherwise N)rrrOrQrZrVrVrWoutputs zGraphRun.output) rrr}rHr~rJrcrKrrh)rrrrrr)rrrYrhr)rrnrYrh)rYr)rYrrR)rQrrYr)rYr)r[r\r]r^rXrrr rrrrrrr`rrrVrVrVrWrMs( 0        rc@seZdZUded<ded<dS)_GraphTaskAsyncIterablez"AsyncIterable[Sequence[GraphTask]]iterabler'rdN)r[r\r]r_rVrVrVrWrs  rc@s*eZdZUded<ded<dZded<dS) _GraphTaskResultrsourcez/EndMarker[Any] | Sequence[GraphTask] | JoinItemrwTrnsource_is_finishedN)r[r\r]r_rrVrVrVrWrs rc@seZdZUded<ded<ded<ded<ed d Zd ed <ed d Zd ed<ed d Zded<ed d Zded<ed d Z ded<ddZ d[ddZ d\d d!Z d]d$d%Z d^d'd(Zd_d+d,Zd`d3d4Zdad8d9Zdbd=d>ZdcdAdBZdddFdGZdedHdIZdfdKdLZdgdSdTZdhdXdYZdZS)irz"Graph[StateT, DepsT, Any, OutputT]rrHr}rJr~r task_groupFrMzdict[TaskID, CancelScope] cancel_scopeszdict[TaskID, GraphTask] active_tasksz)dict[tuple[JoinID, NodeRunID], JoinState]active_reducersz(MemoryObjectSendStream[_GraphTaskResult]rz+MemoryObjectReceiveStream[_GraphTaskResult]rcCs(i|_i|_i|_tt\|_|_dSrR)rrrrrrrrZrVrVrW __post_init__sz_GraphIterator.__post_init__ first_taskrrYbAsyncGenerator[EndMarker[OutputT] | Sequence[GraphTask], EndMarker[OutputT] | Sequence[GraphTask]]c Cs|j4IdHz||j|j<||g|j4IdH|js(|jr|j2zz3dHW}t|jtr<|j}n|jV}t|t rn| |j jIdH|jrX|j j WdIdHWWdIdHdSt|tr|}|j|jj}t|jdddD]%\}}|j|kr|j|jr|jdt|j|}n|j}|j} nqtd|jj|j} t| tsJd| |j|j| f} | dur| } t| |} |j|j| f<t|j|j | d} | !| | j"|j#| _"| j$r|%|| IdHn |D] }||j|j<qt&|j'}g}|(|j |D].\}} |j)|| f} |jj|} t| ts?Jd| |*| | j"| j+}|,|q |rc|D] }||j|j<qT||t|t-rt|jt-rdd|D}|jD]}|j|vr| |jIdHqz|||j.r| |j jIdH|jsnq+6|jrt&|j/D]\\}} } d}|jj0|t1}|j|}|D]S}|j/D]E\\}}}||krd}d}| j+D]}|j|jkr|j}nq|j+D]}|j|jkr|j}nq|r|r||krd}nq|rnq|r%q|j)|| f|jj|} t| ts@Jd| |*| | j"| j+}|V}t|t rn|j j WdIdHWWdIdHdS|D] }||j|j<qpd d|D}|D]}|j|vr| |jIdHq||q|js(|js(WdIdHn 1IdHswYWnt2y|j j YWdIdHdSwWdIdHtd 1IdHswYtd ) NrzParent fork run not foundzExpected a `Join` but got )r}r~ join_statecSh|]}|jqSrVr.0trVrVrW ]z,_GraphIterator.iter_graph..FTcSrrVrrrVrVrWrrzpGraph run completed, but no result was produced. This is either a bug in the graph or a bug in the graph runner.)3rrr_handle_execution_requestrrrrwrarO _finish_taskrr cancel_scopecancelrrxrbfork_id enumeraterdr{len node_run_idrvrpr.ruinitial_factoryr0r1r}r~reducecurrentrccancelled_sibling_tasks_cancel_sibling_taskslistry_get_completed_fork_runspop_handle_non_fork_edgesdownstream_fork_stackextendrritemsrsset GeneratorExit)rUr task_resultmaybe_overridden_resultrwparent_fork_idixr fork_run_id join_noderrcontextnew_tasktasks_by_id_values join_tasksrb new_tasks new_task_idsr should_skiprzjoin_parent_forkintermediate_join_id other_join_id_other_join_statejoin_parent_fork_run_idother_parent_fork_run_idfsirVrVrWrs:                P          * ##z_GraphIterator.iter_graphrr-Nonecs2|j|d}|dur||j|ddSrR)rrrr)rUrscoperVrVrWrs z_GraphIterator._finish_taskrequestSequence[GraphTask]cCs4|D]}||j|j<q|D] }|j|j|q dSrR)rrr start_soon_run_tracked_task)rUrr rVrVrWrs z(_GraphIterator._handle_execution_requestt_cstU}||j|j<||IdH}t|tr=|j2z3dHW}|jt ||dIdHq6|jt |gIdHn|jt ||IdHWddSWddS1s\wYdS)NF) rrr _run_taskrrrrsendr)rUrrrwr rVrVrWrs  "z _GraphIterator._run_tracked_tasktaskMEndMarker[OutputT] | Sequence[GraphTask] | _GraphTaskAsyncIterable | JoinItemc s.|j}|j}|j}|j}|j}|jj|}t|tt Br$| |||St|t rqt +}|jj r<|td|j|dttttf|||d} || IdH} Wdn1sZwYt|trj|| |S| || |St|tr|t|||St|tr||||St|trt|St|dS)Nzrun node {node_id})rnoder}r~rc)r}r~rrcrdrrprr4r3 _handle_edgesr>r rorr$rr?rHrJrcallr= _handle_noder.rar%_handle_decisionr2rOr) rUr!r}r~rrcrdr#r step_contextrrVrVrWrs4         z_GraphIterator._run_taskdecisionDecision[StateT, DepsT, Any]rcrrdr'c Cs|jD]R}|j}|dur||}n8t|j}|tthvrd}n*t|tur,|t|v}nzt ||}Wnt yH}z t d|d|d}~ww|rU| |j ||Sqt d|d|d)NTzDecision branch source z is not a valid type.zNo branch matched inputs z for decision node .)branchesmatchesrArrobjectrrrr TypeErrorrv _handle_pathpath) rUr*rcrdbranch match_tester inputs_match branch_sourceerVrVrWr(s&     z_GraphIterator._handle_decision next_node'BaseNode[StateT, DepsT, Any] | End[Any]3Sequence[GraphTask] | JoinItem | EndMarker[OutputT]cCs~t|trt|jj|j|gSt|trt|jj|j|St|t r/t |j }t|j||gSt|t r9t |jSt|dSrR)rr@rsteprrcr/rajoinrBr=rrCrOdatar)rUr8rd node_steprVrVrWr' s       z_GraphIterator._handle_noderIterable[GraphTask]list[tuple[JoinID, NodeRunID]]cCs`g}ddt|jD}|jD]\}}||}|durq||||r-|||fq|S)NcSsi|]\}}|j|qSrVr)rrrrVrVrW #sz;_GraphIterator._get_completed_fork_runs..)rrdrkeysru_is_fork_run_completedappend)rUrrcompleted_fork_runsfork_run_indicesrbrfork_run_indexrVrVrWrs z'_GraphIterator._get_completed_fork_runsr2r;cCs|jsgS|jd}t|ttBrJdt|tr"t|j||gSt|tr;|t |j |j |d}| |j ||St|trH| |j ||St|dS)Nrz@These markers should be removed from paths during graph buildingr$)rrr:r7r8rdestination_idr< transformr?r}r~r1 next_pathr9r)rUr2rcrditemrVrVrWr1/s     z_GraphIterator._handle_pathr#r5-Sequence[GraphTask] | _GraphTaskAsyncIterablecCs&t|tr ||||S||||SrR)rr3_handle_fork_edgesr)rUr#rcrdrVrVrWr%As z_GraphIterator._handle_edgescCs4|jj|jg}t|dksJ||d||S)Nr)rrqrurrr1)rUr#rcrdedgesrVrVrWrIsz%_GraphIterator._handle_non_fork_edgesFork[Any, Any]c sPjjjgtdksttrjrJjfg}tt t jrj }durKjj |}t|ts?Jt|j|f<trotD]\}}d|tj|f} || 7}qS|Strdfdd } t| StdtD]\} } || tj| f7}q|S) NrOrrY"AsyncIterator[Sequence[GraphTask]]c sNd}2z3dHW}d|tj|f}|V|d7}q6dS)NrrO)r1r(r) thread_index input_item item_tasksrPrdrcr#rrUrVrWhandle_async_iterableis z@_GraphIterator._handle_fork_edges..handle_async_iterablezCannot map non-iterable value: )rYrR)rrqrurrrr3is_mapr,rrrdownstream_join_idrpr.r0rr_is_any_iterablerr1r(_is_any_async_iterablerrv) rUr#rcrdr rbrrSrTrUrWrr2rVrVrWrNNs4   $z!_GraphIterator._handle_fork_edgestasksrbr*rr,rncCsN|j|}|D]}|dd|jDvr#|j|jvs|j|kr"dSq qdS)NcSrrVrA)rrrVrVrWrrz8_GraphIterator._is_fork_run_completed..FT)rrxrdrintermediate_nodes)rUr\rbr parent_forkrrVrVrWrD{s z%_GraphIterator._is_fork_run_completedrr&rcsntt}|jD]\}}|jD]}|j|kr%|j|kr%||n qq |D] }||IdHq*dSrR) rr-rrrdrraddr)rUrrtask_ids_to_cancelrrrLrVrVrWrs   z$_GraphIterator._cancel_sibling_tasksN)rrrYr)rr-rYr)rrrYr)rr)r!rrYr")r*r+rcrrdr'rYr)r8r9rdr'rYr:)rrrr?rYr@)r2r;rcrrdr'rYr)r#r5rcrrdr'rYrM)r#r5rcrrdr'rYr)r#rQrcrrdr'rYrM)r\r?rbr*rr,rYrn)rr&rr,)r[r\r]r_rrrrrrrrrrrrr(r'rr1r%rrNrDrrVrVrVrWrs4   *   #       - rrrrYTypeGuard[Iterable[Any]]cC t|tSrR)rrrrVrVrWrZ rZTypeGuard[AsyncIterable[Any]]cCrbrR)rrrcrVrVrWr[rdr[c csTtrdVdSzdVWdSty)}z|jd}|jdur#d|_|d}~ww)Nr)rrFr __cause__)r7 exceptionrVrVrWrs    r)rrrYra)rrrYre)or^ __future__r _annotationssysrcollections.abcrrrrr contextlibrr r r r dataclassesr rtypingrrrrrrrrranyiorrr anyio.abcranyio.streams.memoryrrtyping_extensionsrrpydantic_graphr pydantic_graph._utilsr!r"r#r$pydantic_graph.beta.decisionr%pydantic_graph.beta.id_typesr&r'r(r)r*r+r,r-pydantic_graph.beta.joinr.r/r0r1pydantic_graph.beta.noder2r3r4pydantic_graph.beta.node_typesr5 pydantic_graph.beta.parent_forksr6pydantic_graph.beta.pathsr7r8r9r:r;r<pydantic_graph.beta.stepr=r>r?r@pydantic_graph.beta.utilrApydantic_graph.nodesrBrC version_infoexceptiongrouprFrrGrHrJrKrLrOrargrrrrrrZr[rrVrVrVrWsz ,   (          G"