o i#@sPddlmZddlmZmZddlmZddlm Z m Z ddl m Z ddl m Z mZmZmZmZddlZddlmZd d lmZmZd d lmZe rPd d lmZdZededZededZdZedZ e ddGdddeeefZ e ddGdddeeefZ!e eefe!eefBZ" GdddeeeefZ#d$d"d#Z$dS)%) annotations)ABCabstractmethod)AbstractAsyncContextManager) dataclassfield)datetime) TYPE_CHECKING AnnotatedAnyGenericLiteralN)TypeVar)BaseNodeEnd)_utils)Graph)StateT NodeSnapshot EndSnapshotSnapshotBaseStatePersistenceSnapshotStatus build_snapshot_list_type_adapterr)defaultRunEndT __unset__)createdpendingrunningsuccesserrorT)kw_onlyc@sveZdZUdZded< ded< dZded< dZd ed < d Zd ed < dZded< e Z ded< dddZ dS)rz;History step describing the execution of a node in a graph.rstatezDAnnotated[BaseNode[StateT, Any, RunEndT], _utils.CustomNodeSchema()]nodeNzdatetime | Nonestart_tsz float | NonedurationrrstatuszLiteral['node']kindstridreturnNonecC|jtkr |j|_dSdSNr,UNSET_SNAPSHOT_IDr&get_snapshot_idselfr6i/var/www/html/karishye-ai-python/venv/lib/python3.10/site-packages/pydantic_graph/persistence/__init__.py __post_init__@ zNodeSnapshot.__post_init__r-r.) __name__ __module__ __qualname____doc____annotations__r'r(r)r*r2r,r8r6r6r6r7r,s"      rc@speZdZUdZded< ded< eejdZded< d Z d ed < e Z d ed < dddZ e dddZdS)rz/History step describing the end of a graph run.rr% End[RunEndT]result)default_factoryrtsendzLiteral['end']r*r+r,r-r.cCr/r0r1r4r6r6r7r8Ur9zEndSnapshot.__post_init__cCs|jS)zShim to get the [`result`][pydantic_graph.persistence.EndSnapshot.result]. Useful to allow `[snapshot.node for snapshot in persistence.history]`. )rAr4r6r6r7r&YszEndSnapshot.nodeNr:)r-r@)r;r<r=r>r?rrnow_utcrCr*r2r,r8propertyr&r6r6r6r7rEs    rc@seZdZdZed)dd Zed*d d Zed+ddZed,ddZed-ddZ ed.ddZ d/ddZ d0d d!Z d1d&d'Z d(S)2rzAbstract base class for storing the state of a graph run. Each instance of a `BaseStatePersistence` subclass should be used for a single graph run. r%r next_nodeBaseNode[StateT, Any, RunEndT]r-r.ct)aSnapshot the state of a graph, when the next step is to run a node. This method should add a [`NodeSnapshot`][pydantic_graph.persistence.NodeSnapshot] to persistence. Args: state: The state of the graph. next_node: The next node to run. NotImplementedError)r5r%rGr6r6r7 snapshot_nodep z"BaseStatePersistence.snapshot_node snapshot_idr+crI)aSnapshot the state of a graph if the snapshot ID doesn't already exist in persistence. This method will generally call [`snapshot_node`][pydantic_graph.persistence.BaseStatePersistence.snapshot_node] but should do so in an atomic way. Args: snapshot_id: The ID of the snapshot to check. state: The state of the graph. next_node: The next node to run. rJ)r5rNr%rGr6r6r7snapshot_node_if_new|sz)BaseStatePersistence.snapshot_node_if_newrDr@crI)aSnapshot the state of a graph when the graph has ended. This method should add an [`EndSnapshot`][pydantic_graph.persistence.EndSnapshot] to persistence. Args: state: The state of the graph. end: data from the end of the run. rJ)r5r%rDr6r6r7 snapshot_endrMz!BaseStatePersistence.snapshot_end!AbstractAsyncContextManager[None]cCst)a{Record the run of the node, or error if the node is already running. Args: snapshot_id: The ID of the snapshot to record. Raises: GraphNodeRunningError: if the node status it not `'created'` or `'pending'`. LookupError: if the snapshot ID is not found in persistence. Returns: An async context manager that records the run of the node. In particular this should set: - [`NodeSnapshot.status`][pydantic_graph.persistence.NodeSnapshot.status] to `'running'` and [`NodeSnapshot.start_ts`][pydantic_graph.persistence.NodeSnapshot.start_ts] when the run starts. - [`NodeSnapshot.status`][pydantic_graph.persistence.NodeSnapshot.status] to `'success'` or `'error'` and [`NodeSnapshot.duration`][pydantic_graph.persistence.NodeSnapshot.duration] when the run finishes. rJ)r5rNr6r6r7 record_runszBaseStatePersistence.record_run$NodeSnapshot[StateT, RunEndT] | NonecrI)aERetrieve a node snapshot with status `'created`' and set its status to `'pending'`. This is used by [`Graph.iter_from_persistence`][pydantic_graph.graph.Graph.iter_from_persistence] to get the next node to run. Returns: The snapshot, or `None` if no snapshot with status `'created`' exists. rJr4r6r6r7 load_next zBaseStatePersistence.load_nextlist[Snapshot[StateT, RunEndT]]crI)aLoad the entire history of snapshots. `load_all` is not used by pydantic-graph itself, instead it's provided to make it convenient to get all [snapshots][pydantic_graph.persistence.Snapshot] from persistence. Returns: The list of snapshots. rJr4r6r6r7load_allrUzBaseStatePersistence.load_allgraphGraph[StateT, Any, RunEndT]cCsL|r$t||j|jWddS1swYdSdS)a@Set the types of the state and run end from a graph. You generally won't need to customise this method, instead implement [`set_types`][pydantic_graph.persistence.BaseStatePersistence.set_types] and [`should_set_types`][pydantic_graph.persistence.BaseStatePersistence.should_set_types]. N)should_set_typesrset_nodes_type_context get_nodes set_typesinferred_types)r5rXr6r6r7set_graph_typess "z$BaseStatePersistence.set_graph_typesboolcCdS)zWhether types need to be set. Implementations should override this method to return `True` when types have not been set if they are needed. Fr6r4r6r6r7rZsz%BaseStatePersistence.should_set_types state_type type[StateT] run_end_type type[RunEndT]cCra)aSet the types of the state and run end. This can be used to create [type adapters][pydantic.TypeAdapter] for serializing and deserializing snapshots, e.g. with [`build_snapshot_list_type_adapter`][pydantic_graph.persistence.build_snapshot_list_type_adapter]. Args: state_type: The state type. run_end_type: The run end type. Nr6)r5rbrdr6r6r7r]s zBaseStatePersistence.set_typesN)r%rrGrHr-r.)rNr+r%rrGrHr-r.)r%rrDr@r-r.)rNr+r-rQ)r-rS)r-rV)rXrYr-r.)r-r`)rbrcrdrer-r.)r;r<r=r>rrLrOrPrRrTrWr_rZr]r6r6r6r7rjs"       rstate_trc run_end_trer-5pydantic.TypeAdapter[list[Snapshot[StateT, RunEndT]]]cCs$tttt||ftdfS)aIBuild a type adapter for a list of snapshots. This method should be called from within [`set_types`][pydantic_graph.persistence.BaseStatePersistence.set_types] where context variables will be set such that Pydantic can create a schema for [`NodeSnapshot.node`][pydantic_graph.persistence.NodeSnapshot.node]. r*)pydantic TypeAdapterlistr r Discriminator)rfrgr6r6r7rs$ r)rfrcrgrer-rh)% __future__r _annotationsabcrr contextlibr dataclassesrrrtypingr r r r r rityping_extensionsrnodesrrrr__all__rrr2rrrrrrr6r6r6r7s4        z