pydantic-graph 0.2.2__py3-none-any.whl → 1.24.0__py3-none-any.whl

pydantic_graph/beta/util.py

@@ -0,0 +1,90 @@
+"""Utility types and functions for type manipulation and introspection.
+
+This module provides helper classes and functions for working with Python's type system,
+including workarounds for type checker limitations and utilities for runtime type inspection.
+"""
+
+from dataclasses import dataclass
+from typing import Any, Generic, cast, get_args, get_origin
+
+from typing_extensions import TypeAliasType, TypeVar
+
+T = TypeVar('T', infer_variance=True)
+"""Generic type variable with inferred variance."""
+
+
+class TypeExpression(Generic[T]):
+    """A workaround for type checker limitations when using complex type expressions.
+
+        This class serves as a wrapper for types that cannot normally be used in positions
+    requiring `type[T]`, such as `Any`, `Union[...]`, or `Literal[...]`. It provides a
+        way to pass these complex type expressions to functions expecting concrete types.
+
+    Example:
+            Instead of `output_type=Union[str, int]` (which may cause type errors),
+            use `output_type=TypeExpression[Union[str, int]]`.
+
+    Note:
+            This is a workaround for the lack of TypeForm in the Python type system.
+    """
+
+    pass
+
+
+TypeOrTypeExpression = TypeAliasType('TypeOrTypeExpression', type[TypeExpression[T]] | type[T], type_params=(T,))
+"""Type alias allowing both direct types and TypeExpression wrappers.
+
+This alias enables functions to accept either regular types (when compatible with type checkers)
+or TypeExpression wrappers for complex type expressions. The correct type should be inferred
+automatically in either case.
+"""
+
+
+def unpack_type_expression(type_: TypeOrTypeExpression[T]) -> type[T]:
+    """Extract the actual type from a TypeExpression wrapper or return the type directly.
+
+    Args:
+        type_: Either a direct type or a TypeExpression wrapper.
+
+    Returns:
+        The unwrapped type, ready for use in runtime type operations.
+    """
+    if get_origin(type_) is TypeExpression:
+        return get_args(type_)[0]
+    return cast(type[T], type_)
+
+
+@dataclass
+class Some(Generic[T]):
+    """Container for explicitly present values in Maybe type pattern.
+
+    This class represents a value that is definitely present, as opposed to None.
+    It's part of the Maybe pattern, similar to Option/Maybe in functional programming,
+    allowing distinction between "no value" (None) and "value is None" (Some(None)).
+    """
+
+    value: T
+    """The wrapped value."""
+
+
+Maybe = TypeAliasType('Maybe', Some[T] | None, type_params=(T,))
+"""Optional-like type that distinguishes between absence and None values.
+
+Unlike Optional[T], Maybe[T] can differentiate between:
+- No value present: represented as None
+- Value is None: represented as Some(None)
+
+This is particularly useful when None is a valid value in your domain.
+"""
+
+
+def get_callable_name(callable_: Any) -> str:
+    """Extract a human-readable name from a callable object.
+
+    Args:
+        callable_: Any callable object (function, method, class, etc.).
+
+    Returns:
+        The callable's __name__ attribute if available, otherwise its string representation.
+    """
+    return getattr(callable_, '__name__', str(callable_))

pydantic_graph/exceptions.py

@@ -15,6 +15,28 @@ class GraphSetupError(TypeError):
         super().__init__(message)
 
 
+class GraphBuildingError(ValueError):
+    """An error raised during graph-building."""
+
+    message: str
+    """The error message."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(message)
+
+
+class GraphValidationError(ValueError):
+    """An error raised during graph validation."""
+
+    message: str
+    """The error message."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(message)
+
+
 class GraphRuntimeError(RuntimeError):
     """Error caused by an issue during graph execution."""
 

pydantic_graph/graph.py

@@ -6,35 +6,20 @@ from collections.abc import AsyncIterator, Sequence
 from contextlib import AbstractContextManager, ExitStack, asynccontextmanager
 from dataclasses import dataclass, field
 from functools import cached_property
+from pathlib import Path
 from typing import Any, Generic, cast, overload
 
-import logfire_api
 import typing_extensions
-from opentelemetry.trace import Span
-from typing_extensions import deprecated
 from typing_inspection import typing_objects
 
 from . import _utils, exceptions, mermaid
-from ._utils import AbstractSpan, get_traceparent
+from ._utils import AbstractSpan, get_traceparent, logfire_span
 from .nodes import BaseNode, DepsT, End, GraphRunContext, NodeDef, RunEndT, StateT
 from .persistence import BaseStatePersistence
 from .persistence.in_mem import SimpleStatePersistence
 
-# while waiting for https://github.com/pydantic/logfire/issues/745
-try:
-    import logfire._internal.stack_info
-except ImportError:
-    pass
-else:
-    from pathlib import Path
-
-    logfire._internal.stack_info.NON_USER_CODE_PREFIXES += (str(Path(__file__).parent.absolute()),)  # pyright: ignore[reportPrivateImportUsage]
-
-
 __all__ = 'Graph', 'GraphRun', 'GraphRunResult'
 
-_logfire = logfire_api.Logfire(otel_scope='pydantic-graph')
-
 
 @dataclass(init=False)
 class Graph(Generic[StateT, DepsT, RunEndT]):
@@ -46,7 +31,7 @@ class Graph(Generic[StateT, DepsT, RunEndT]):
     Here's a very simple example of a graph which increments a number by 1, but makes sure the number is never
     42 at the end.
 
-    ```py {title="never_42.py" noqa="I001" py="3.10"}
+    ```py {title="never_42.py" noqa="I001"}
     from __future__ import annotations
 
     from dataclasses import dataclass
@@ -143,7 +128,7 @@ class Graph(Generic[StateT, DepsT, RunEndT]):
 
         Here's an example of running the graph from [above][pydantic_graph.graph.Graph]:
 
-        ```py {title="run_never_42.py" noqa="I001" py="3.10"}
+        ```py {title="run_never_42.py" noqa="I001" requires="never_42.py"}
         from never_42 import Increment, MyState, never_42_graph
 
         async def main():
@@ -197,7 +182,7 @@ class Graph(Generic[StateT, DepsT, RunEndT]):
         Returns:
             The result type from ending the run and the history of the run.
         """
-        if infer_name and self.name is None:
+        if infer_name and self.name is None:  # pragma: no branch
             self._infer_name(inspect.currentframe())
 
         return _utils.get_event_loop().run_until_complete(
@@ -212,7 +197,7 @@ class Graph(Generic[StateT, DepsT, RunEndT]):
         state: StateT = None,
         deps: DepsT = None,
         persistence: BaseStatePersistence[StateT, RunEndT] | None = None,
-        span: AbstractContextManager[Span] | None = None,
+        span: AbstractContextManager[AbstractSpan] | None = None,
         infer_name: bool = True,
     ) -> AsyncIterator[GraphRun[StateT, DepsT, RunEndT]]:
         """A contextmanager which can be used to iterate over the graph's nodes as they are executed.
@@ -253,8 +238,12 @@ class Graph(Generic[StateT, DepsT, RunEndT]):
         with ExitStack() as stack:
             entered_span: AbstractSpan | None = None
             if span is None:
-                if self.auto_instrument:
-                    entered_span = stack.enter_context(logfire_api.span('run graph {graph.name}', graph=self))
+                if self.auto_instrument:  # pragma: no branch
+                    # Separate variable because we actually don't want logfire's f-string magic here,
+                    # we want the span_name to be preformatted for other backends
+                    # as requested in https://github.com/pydantic/pydantic-ai/issues/3173.
+                    span_name = f'run graph {self.name}'
+                    entered_span = stack.enter_context(logfire_span(span_name, graph=self))
             else:
                 entered_span = stack.enter_context(span)
             traceparent = None if entered_span is None else get_traceparent(entered_span)
@@ -302,8 +291,8 @@ class Graph(Generic[StateT, DepsT, RunEndT]):
 
         snapshot.node.set_snapshot_id(snapshot.id)
 
-        if self.auto_instrument and span is None:
-            span = logfire_api.span('run graph {graph.name}', graph=self)
+        if self.auto_instrument and span is None:  # pragma: no branch
+            span = logfire_span('run graph {graph.name}', graph=self)
 
         with ExitStack() as stack:
             entered_span = None if span is None else stack.enter_context(span)
@@ -343,43 +332,6 @@ class Graph(Generic[StateT, DepsT, RunEndT]):
         persistence.set_graph_types(self)
         await persistence.snapshot_node(state, node)
 
-    @deprecated('`next` is deprecated, use `async with graph.iter(...) as run:  run.next()` instead')
-    async def next(
-        self,
-        node: BaseNode[StateT, DepsT, RunEndT],
-        persistence: BaseStatePersistence[StateT, RunEndT],
-        *,
-        state: StateT = None,
-        deps: DepsT = None,
-        infer_name: bool = True,
-    ) -> BaseNode[StateT, DepsT, Any] | End[RunEndT]:
-        """Run a node in the graph and return the next node to run.
-
-        Args:
-            node: The node to run.
-            persistence: State persistence interface, defaults to
-                [`SimpleStatePersistence`][pydantic_graph.SimpleStatePersistence] if `None`.
-            state: The current state of the graph.
-            deps: The dependencies of the graph.
-            infer_name: Whether to infer the graph name from the calling frame.
-
-        Returns:
-            The next node to run or [`End`][pydantic_graph.nodes.End] if the graph has finished.
-        """
-        if infer_name and self.name is None:
-            self._infer_name(inspect.currentframe())
-
-        persistence.set_graph_types(self)
-        run = GraphRun[StateT, DepsT, RunEndT](
-            graph=self,
-            start_node=node,
-            persistence=persistence,
-            state=state,
-            deps=deps,
-            traceparent=None,
-        )
-        return await run.next(node)
-
     def mermaid_code(
         self,
         *,
@@ -411,7 +363,7 @@ class Graph(Generic[StateT, DepsT, RunEndT]):
 
         Here's an example of generating a diagram for the graph from [above][pydantic_graph.graph.Graph]:
 
-        ```py {title="mermaid_never_42.py" py="3.10"}
+        ```py {title="mermaid_never_42.py" requires="never_42.py"}
         from never_42 import Increment, never_42_graph
 
         print(never_42_graph.mermaid_code(start_node=Increment))
@@ -532,7 +484,7 @@ class Graph(Generic[StateT, DepsT, RunEndT]):
                     # break the inner (bases) loop
                     break
 
-        if not _utils.is_set(state_type):
+        if not _utils.is_set(state_type):  # pragma: no branch
             # state defaults to None, so use that if we can't infer it
             state_type = None
         if not _utils.is_set(run_end_type):
@@ -585,9 +537,9 @@ class Graph(Generic[StateT, DepsT, RunEndT]):
                 if item is self:
                     self.name = name
                     return
-            if parent_frame.f_locals != parent_frame.f_globals:
+            if parent_frame.f_locals != parent_frame.f_globals:  # pragma: no branch
                 # if we couldn't find the agent in locals and globals are a different dict, try globals
-                for name, item in parent_frame.f_globals.items():
+                for name, item in parent_frame.f_globals.items():  # pragma: no branch
                     if item is self:
                         self.name = name
                         return
@@ -601,7 +553,7 @@ class GraphRun(Generic[StateT, DepsT, RunEndT]):
     through nodes as they run, either by `async for` iteration or by repeatedly calling `.next(...)`.
 
     Here's an example of iterating over the graph from [above][pydantic_graph.graph.Graph]:
-    ```py {title="iter_never_42.py" noqa="I001" py="3.10"}
+    ```py {title="iter_never_42.py" noqa="I001" requires="never_42.py"}
     from copy import deepcopy
     from never_42 import Increment, MyState, never_42_graph
 
@@ -717,7 +669,7 @@ class GraphRun(Generic[StateT, DepsT, RunEndT]):
         under dynamic conditions. The graph run should stop when you return an [`End`][pydantic_graph.nodes.End] node.
 
         Here's an example of using `next` to drive the graph from [above][pydantic_graph.graph.Graph]:
-        ```py {title="next_never_42.py" noqa="I001" py="3.10"}
+        ```py {title="next_never_42.py" noqa="I001" requires="never_42.py"}
         from copy import deepcopy
         from pydantic_graph import End
         from never_42 import Increment, MyState, never_42_graph
@@ -775,11 +727,15 @@ class GraphRun(Generic[StateT, DepsT, RunEndT]):
             raise exceptions.GraphRuntimeError(f'Node `{node}` is not in the graph.')
 
         with ExitStack() as stack:
-            if self.graph.auto_instrument:
-                stack.enter_context(_logfire.span('run node {node_id}', node_id=node_id, node=node))
+            if self.graph.auto_instrument:  # pragma: no branch
+                # Separate variable because we actually don't want logfire's f-string magic here,
+                # we want the span_name to be preformatted for other backends
+                # as requested in https://github.com/pydantic/pydantic-ai/issues/3173.
+                span_name = f'run node {node_id}'
+                stack.enter_context(logfire_span(span_name, node_id=node_id, node=node))
 
             async with self.persistence.record_run(node_snapshot_id):
-                ctx = GraphRunContext(self.state, self.deps)
+                ctx = GraphRunContext(state=self.state, deps=self.deps)
                 self._next_node = await node.run(ctx)
 
         if isinstance(self._next_node, End):

pydantic_graph/mermaid.py

@@ -5,11 +5,11 @@ import re
 from collections.abc import Iterable, Sequence
 from pathlib import Path
 from textwrap import indent
-from typing import TYPE_CHECKING, Annotated, Any, Literal
+from typing import TYPE_CHECKING, Annotated, Any, Literal, TypeAlias
 
 import httpx
 from annotated_types import Ge, Le
-from typing_extensions import TypeAlias, TypedDict, Unpack
+from typing_extensions import TypedDict, Unpack
 
 from .nodes import BaseNode
 

pydantic_graph/nodes.py

@@ -4,10 +4,10 @@ import copy
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, is_dataclass
 from functools import cache
-from typing import Any, ClassVar, Generic, get_type_hints
+from typing import Any, ClassVar, Generic, get_origin, get_type_hints
 from uuid import uuid4
 
-from typing_extensions import Never, Self, TypeVar, get_origin
+from typing_extensions import Never, Self, TypeVar
 
 from . import _utils, exceptions
 
@@ -24,12 +24,10 @@ DepsT = TypeVar('DepsT', default=None, contravariant=True)
 """Type variable for the dependencies of a graph and node."""
 
 
-@dataclass
+@dataclass(kw_only=True)
 class GraphRunContext(Generic[StateT, DepsT]):
     """Context for a graph."""
 
-    # TODO: Can we get rid of this struct and just pass both these things around..?
-
     state: StateT
     """The state of the graph."""
     deps: DepsT
@@ -94,8 +92,8 @@ class BaseNode(ABC, Generic[StateT, DepsT, NodeRunEndT]):
         docstring = cls.__doc__
         # dataclasses get an automatic docstring which is just their signature, we don't want that
         if docstring and is_dataclass(cls) and docstring.startswith(f'{cls.__name__}('):
-            docstring = None
-        if docstring:
+            docstring = None  # pragma: no cover
+        if docstring:  # pragma: no branch
             # remove indentation from docstring
             import inspect
 
@@ -121,7 +119,6 @@ class BaseNode(ABC, Generic[StateT, DepsT, NodeRunEndT]):
             if return_type_origin is End:
                 end_edge = edge
             elif return_type_origin is BaseNode:
-                # TODO: Should we disallow this?
                 returns_base_node = True
             elif issubclass(return_type_origin, BaseNode):
                 next_node_edges[return_type.get_node_id()] = edge
@@ -129,12 +126,12 @@ class BaseNode(ABC, Generic[StateT, DepsT, NodeRunEndT]):
                 raise exceptions.GraphSetupError(f'Invalid return type: {return_type}')
 
         return NodeDef(
-            cls,
-            cls.get_node_id(),
-            cls.get_note(),
-            next_node_edges,
-            end_edge,
-            returns_base_node,
+            node=cls,
+            node_id=cls.get_node_id(),
+            note=cls.get_note(),
+            next_node_edges=next_node_edges,
+            end_edge=end_edge,
+            returns_base_node=returns_base_node,
         )
 
     def deep_copy(self) -> Self:
@@ -174,7 +171,7 @@ def generate_snapshot_id(node_id: str) -> str:
     return f'{node_id}:{uuid4().hex}'
 
 
-@dataclass
+@dataclass(frozen=True)
 class Edge:
     """Annotation to apply a label to an edge in a graph."""
 
@@ -182,7 +179,7 @@ class Edge:
     """Label for the edge."""
 
 
-@dataclass
+@dataclass(kw_only=True)
 class NodeDef(Generic[StateT, DepsT, NodeRunEndT]):
     """Definition of a node.
 

pydantic_graph/persistence/__init__.py

@@ -4,7 +4,7 @@ from abc import ABC, abstractmethod
 from contextlib import AbstractAsyncContextManager
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import TYPE_CHECKING, Annotated, Any, Generic, Literal, Union
+from typing import TYPE_CHECKING, Annotated, Any, Generic, Literal
 
 import pydantic
 from typing_extensions import TypeVar
@@ -41,7 +41,7 @@ SnapshotStatus = Literal['created', 'pending', 'running', 'success', 'error']
 """
 
 
-@dataclass
+@dataclass(kw_only=True)
 class NodeSnapshot(Generic[StateT, RunEndT]):
     """History step describing the execution of a node in a graph."""
 
@@ -66,7 +66,7 @@ class NodeSnapshot(Generic[StateT, RunEndT]):
             self.id = self.node.get_snapshot_id()
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EndSnapshot(Generic[StateT, RunEndT]):
     """History step describing the end of a graph run."""
 
@@ -95,7 +95,7 @@ class EndSnapshot(Generic[StateT, RunEndT]):
         return self.result
 
 
-Snapshot = Union[NodeSnapshot[StateT, RunEndT], EndSnapshot[StateT, RunEndT]]
+Snapshot = NodeSnapshot[StateT, RunEndT] | EndSnapshot[StateT, RunEndT]
 """A step in the history of a graph run.
 
 [`Graph.run`][pydantic_graph.graph.Graph.run] returns a list of these steps describing the execution of the graph,

pydantic_graph/persistence/_utils.py

@@ -31,7 +31,7 @@ class CustomNodeSchema:
             nodes_type = nodes[0]
         else:
             nodes_annotated = [Annotated[node, pydantic.Tag(node.get_node_id())] for node in nodes]
-            nodes_type = Annotated[Union[tuple(nodes_annotated)], pydantic.Discriminator(self._node_discriminator)]
+            nodes_type = Annotated[Union[tuple(nodes_annotated)], pydantic.Discriminator(self._node_discriminator)]  # noqa: UP007
 
         schema = handler(nodes_type)
         schema['serialization'] = core_schema.wrap_serializer_function_ser_schema(

pydantic_graph/persistence/file.py

@@ -1,6 +1,5 @@
 from __future__ import annotations as _annotations
 
-import asyncio
 import secrets
 from collections.abc import AsyncIterator
 from contextlib import AsyncExitStack, asynccontextmanager
@@ -9,6 +8,7 @@ from pathlib import Path
 from time import perf_counter
 from typing import Any
 
+import anyio
 import pydantic
 
 from .. import _utils as _graph_utils, exceptions
@@ -59,7 +59,7 @@ class FileStatePersistence(BaseStatePersistence[StateT, RunEndT]):
     ) -> None:
         async with self._lock():
             snapshots = await self.load_all()
-            if not any(s.id == snapshot_id for s in snapshots):
+            if not any(s.id == snapshot_id for s in snapshots):  # pragma: no branch
                 await self._append_save(NodeSnapshot(state=state, node=next_node), lock=False)
 
     async def snapshot_end(self, state: StateT, end: End[RunEndT]) -> None:
@@ -155,24 +155,23 @@ class FileStatePersistence(BaseStatePersistence[StateT, RunEndT]):
         """
         lock_file = self.json_file.parent / f'{self.json_file.name}.pydantic-graph-persistence-lock'
         lock_id = secrets.token_urlsafe().encode()
-        await asyncio.wait_for(_get_lock(lock_file, lock_id), timeout=timeout)
+
+        with anyio.fail_after(timeout):
+            while not await _file_append_check(lock_file, lock_id):
+                await anyio.sleep(0.01)
+
         try:
             yield
         finally:
             await _graph_utils.run_in_executor(lock_file.unlink, missing_ok=True)
 
 
-async def _get_lock(lock_file: Path, lock_id: bytes):
-    # TODO replace with inline code and `asyncio.timeout` when we drop 3.9
-    while not await _graph_utils.run_in_executor(_file_append_check, lock_file, lock_id):
-        await asyncio.sleep(0.01)
-
-
-def _file_append_check(file: Path, content: bytes) -> bool:
-    if file.exists():
+async def _file_append_check(file: Path, content: bytes) -> bool:
+    path = anyio.Path(file)
+    if await path.exists():
         return False
 
-    with file.open(mode='ab') as f:
-        f.write(content + b'\n')
+    async with await anyio.open_file(path, mode='ab') as f:
+        await f.write(content + b'\n')
 
-    return file.read_bytes().startswith(content)
+    return (await path.read_bytes()).startswith(content)

pydantic_graph/persistence/in_mem.py

@@ -45,7 +45,7 @@ class SimpleStatePersistence(BaseStatePersistence[StateT, RunEndT]):
         self, snapshot_id: str, state: StateT, next_node: BaseNode[StateT, Any, RunEndT]
     ) -> None:
         if self.last_snapshot and self.last_snapshot.id == snapshot_id:
-            return
+            return  # pragma: no cover
         else:
             await self.snapshot_node(state, next_node)
 
@@ -65,7 +65,7 @@ class SimpleStatePersistence(BaseStatePersistence[StateT, RunEndT]):
         start = perf_counter()
         try:
             yield
-        except Exception:
+        except Exception:  # pragma: no cover
             self.last_snapshot.duration = perf_counter() - start
             self.last_snapshot.status = 'error'
             raise
@@ -76,7 +76,7 @@ class SimpleStatePersistence(BaseStatePersistence[StateT, RunEndT]):
     async def load_next(self) -> NodeSnapshot[StateT, RunEndT] | None:
         if isinstance(self.last_snapshot, NodeSnapshot) and self.last_snapshot.status == 'created':
             self.last_snapshot.status = 'pending'
-            return self.last_snapshot
+            return copy.deepcopy(self.last_snapshot)
 
     async def load_all(self) -> list[Snapshot[StateT, RunEndT]]:
         raise NotImplementedError('load is not supported for SimpleStatePersistence')
@@ -143,7 +143,7 @@ class FullStatePersistence(BaseStatePersistence[StateT, RunEndT]):
     async def load_next(self) -> NodeSnapshot[StateT, RunEndT] | None:
         if snapshot := next((s for s in self.history if isinstance(s, NodeSnapshot) and s.status == 'created'), None):
             snapshot.status = 'pending'
-            return snapshot
+            return copy.deepcopy(snapshot)
 
     async def load_all(self) -> list[Snapshot[StateT, RunEndT]]:
         return self.history

{pydantic_graph-0.2.2.dist-info → pydantic_graph-1.24.0.dist-info}/METADATA

@@ -1,14 +1,15 @@
 Metadata-Version: 2.4
 Name: pydantic-graph
-Version: 0.2.2
+Version: 1.24.0
 Summary: Graph and state machine library
 Project-URL: Homepage, https://ai.pydantic.dev/graph/tree/main/pydantic_graph
 Project-URL: Source, https://github.com/pydantic/pydantic-ai
 Project-URL: Documentation, https://ai.pydantic.dev/graph
 Project-URL: Changelog, https://github.com/pydantic/pydantic-ai/releases
-Author-email: Samuel Colvin <samuel@pydantic.dev>
+Author-email: Samuel Colvin <samuel@pydantic.dev>, Marcelo Trylesinski <marcelotryle@gmail.com>, David Montague <david@pydantic.dev>, Alex Hall <alex@pydantic.dev>, Douwe Maan <douwe@pydantic.dev>
 License-Expression: MIT
-Classifier: Development Status :: 4 - Beta
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Environment :: MacOS X
 Classifier: Intended Audience :: Developers
@@ -20,16 +21,15 @@ Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Internet
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: httpx>=0.27
-Requires-Dist: logfire-api>=1.2.0
+Requires-Dist: logfire-api>=3.14.1
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Description-Content-Type: text/markdown
@@ -44,10 +44,10 @@ Description-Content-Type: text/markdown
 
 Graph and finite state machine library.
 
-This library is developed as part of [PydanticAI](https://ai.pydantic.dev), however it has no dependency
-on `pydantic-ai` or related packages and can be considered as a pure graph-based state machine library. You may find it useful whether or not you're using PydanticAI or even building with GenAI.
+This library is developed as part of [Pydantic AI](https://ai.pydantic.dev), however it has no dependency
+on `pydantic-ai` or related packages and can be considered as a pure graph-based state machine library. You may find it useful whether or not you're using Pydantic AI or even building with GenAI.
 
-As with PydanticAI, this library prioritizes type safety and use of common Python syntax over esoteric, domain-specific use of Python syntax.
+As with Pydantic AI, this library prioritizes type safety and use of common Python syntax over esoteric, domain-specific use of Python syntax.
 
 `pydantic-graph` allows you to define graphs using standard Python syntax. In particular, edges are defined using the return type hint of nodes.
 
@@ -55,7 +55,7 @@ Full documentation is available at [ai.pydantic.dev/graph](https://ai.pydantic.d
 
 Here's a basic example:
 
-```python {noqa="I001" py="3.10"}
+```python {noqa="I001"}
 from __future__ import annotations
 
 from dataclasses import dataclass

pydantic_graph-1.24.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+pydantic_graph/__init__.py,sha256=qkrSmWLpnNhD7mLBWV70iS46vy2vFiU2zUModG31wPQ,593
+pydantic_graph/_utils.py,sha256=f0B1VIRxfAslj5UIfBVRzXhIJkDXyF8P3B9V22Q7o7U,6782
+pydantic_graph/exceptions.py,sha256=aeaBf2H18dV7YCNZKZmiXiI6Fyys2qQdunZwd7TSCPk,1648
+pydantic_graph/graph.py,sha256=rEm_5PzRs-5k6Y0mmaF5SGhF0wPA2JSclNAEZtBUZpA,33942
+pydantic_graph/mermaid.py,sha256=u8xM8eEAOWV0TkqEAPJJ9jL2XEZnJ_H7yNGhulg7SL4,10045
+pydantic_graph/nodes.py,sha256=CkY3lrC6jqZtzwhSRjFzmM69TdFFFrr58XSDU4THKHA,7450
+pydantic_graph/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_graph/beta/__init__.py,sha256=VVmbEFaCSXYHwXqS4pANg4B3cn_c86tT62tW_EXcuyw,751
+pydantic_graph/beta/decision.py,sha256=x-Ta549b-j5hyBPUWFdwRQDRaJqnBHF1pfBP9L8I3vI,11239
+pydantic_graph/beta/graph.py,sha256=-T-HbVyBC3qgg_-dXURnCbI6K_mqj25jDVh_RMlVsS8,42811
+pydantic_graph/beta/graph_builder.py,sha256=2sD7TR8oGg4Gatrms0jE17NXzQN7drzUvaJKs5BvILU,43329
+pydantic_graph/beta/id_types.py,sha256=FZ3rYSubF6g_Ocv0faL3yJsy1lNN9AGZl9f_izvORUg,2814
+pydantic_graph/beta/join.py,sha256=rzCumDX_YgaU_a5bisfbjbbOuI3IwSZsCZs9TC0T9E4,8002
+pydantic_graph/beta/mermaid.py,sha256=vpB9laZeTaS-P6BJplyN7DLFz0ppRVafGjBfqRiTh-s,7128
+pydantic_graph/beta/node.py,sha256=cTEGKiT3Lutg-PWxBbZDihpnBTVoPMSyCbfB50fjKeY,3071
+pydantic_graph/beta/node_types.py,sha256=Ha1QPbAHqmJ1ARb359b8LOJK-jZDMO_ZyHkYv9Zbglw,3399
+pydantic_graph/beta/parent_forks.py,sha256=lMCT3slwDuZtiLZImqXuW-i0ZftONCWGr7RTpCAe9dY,9691
+pydantic_graph/beta/paths.py,sha256=LkFvgnyNa1lHdFkN83F7Dgsdg9Q2y0zYrLyqprQiQiY,16068
+pydantic_graph/beta/step.py,sha256=n0JstmxM6Z2rCc2EPUrSAp4MS4IjM2mZsE0ymeekzxU,8683
+pydantic_graph/beta/util.py,sha256=F7IkSC0U-tU1yOxncslyOrZ5HlrZIdafBJARsPetIHQ,3153
+pydantic_graph/persistence/__init__.py,sha256=NLBGvUWhem23EdMHHxtX0XgTS2vyixmuWtWmZKj_U58,8968
+pydantic_graph/persistence/_utils.py,sha256=6ySxCc1lFz7bbLUwDLkoZWNqi8VNLBVU4xxJbKI23fQ,2264
+pydantic_graph/persistence/file.py,sha256=XZy295cGc86HfUl_KuB-e7cECZW3bubiEdyJMVQ1OD0,6906
+pydantic_graph/persistence/in_mem.py,sha256=MmahaVpdzmDB30Dm3ZfSCZBqgmx6vH4HXdBaWwVF0K0,6799
+pydantic_graph-1.24.0.dist-info/METADATA,sha256=MuevkYyRJr96QAs8gcaDetAButYgPY35d89YQ7Ruluw,3895
+pydantic_graph-1.24.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_graph-1.24.0.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_graph-1.24.0.dist-info/RECORD,,