pydantic-graph 1.22.0__tar.gz → 1.34.0__tar.gz

{pydantic_graph-1.22.0 → pydantic_graph-1.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-graph
-Version: 1.22.0
+Version: 1.34.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

{pydantic_graph-1.22.0 → pydantic_graph-1.34.0}/pydantic_graph/beta/graph.py

@@ -13,7 +13,7 @@ from contextlib import AbstractContextManager, AsyncExitStack, ExitStack, asyncc
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Generic, Literal, TypeGuard, cast, get_args, get_origin, overload
 
-from anyio import CancelScope, create_memory_object_stream, create_task_group
+from anyio import BrokenResourceError, CancelScope, create_memory_object_stream, create_task_group
 from anyio.abc import TaskGroup
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from typing_extensions import TypeVar, assert_never
@@ -43,9 +43,9 @@ from pydantic_graph.beta.util import unpack_type_expression
 from pydantic_graph.nodes import BaseNode, End
 
 if sys.version_info < (3, 11):
-    from exceptiongroup import ExceptionGroup as ExceptionGroup  # pragma: lax no cover
+    from exceptiongroup import BaseExceptionGroup as BaseExceptionGroup  # pragma: lax no cover
 else:
-    ExceptionGroup = ExceptionGroup  # pragma: lax no cover
+    BaseExceptionGroup = BaseExceptionGroup  # pragma: lax no cover
 
 if TYPE_CHECKING:
     from pydantic_graph.beta.mermaid import StateDiagramDirection
@@ -562,7 +562,7 @@ class _GraphIterator(Generic[StateT, DepsT, OutputT]):
         self.iter_stream_sender, self.iter_stream_receiver = create_memory_object_stream[_GraphTaskResult]()
         self._next_node_run_id = 1
 
-    async def iter_graph(  # noqa C901
+    async def iter_graph(  # noqa: C901
         self, first_task: GraphTask
     ) -> AsyncGenerator[EndMarker[OutputT] | Sequence[GraphTask], EndMarker[OutputT] | Sequence[GraphTask]]:
         async with self.iter_stream_sender:
@@ -748,12 +748,15 @@ class _GraphIterator(Generic[StateT, DepsT, OutputT]):
         with CancelScope() as scope:
             self.cancel_scopes[t_.task_id] = scope
             result = await self._run_task(t_)
-            if isinstance(result, _GraphTaskAsyncIterable):
-                async for new_tasks in result.iterable:
-                    await self.iter_stream_sender.send(_GraphTaskResult(t_, new_tasks, False))
-                await self.iter_stream_sender.send(_GraphTaskResult(t_, []))
-            else:
-                await self.iter_stream_sender.send(_GraphTaskResult(t_, result))
+            try:
+                if isinstance(result, _GraphTaskAsyncIterable):
+                    async for new_tasks in result.iterable:
+                        await self.iter_stream_sender.send(_GraphTaskResult(t_, new_tasks, False))
+                    await self.iter_stream_sender.send(_GraphTaskResult(t_, []))
+                else:
+                    await self.iter_stream_sender.send(_GraphTaskResult(t_, result))
+            except BrokenResourceError:
+                pass  # pragma: no cover # This can happen in difficult-to-reproduce circumstances when cancelling an asyncio task
 
     async def _run_task(
         self,
@@ -970,7 +973,7 @@ def _unwrap_exception_groups():
     else:
         try:
             yield
-        except ExceptionGroup as e:
+        except BaseExceptionGroup as e:
             exception = e.exceptions[0]
             if exception.__cause__ is None:
                 # bizarrely, this prevents recursion errors when formatting the exception for logfire

{pydantic_graph-1.22.0 → pydantic_graph-1.34.0}/pydantic_graph/beta/graph_builder.py

@@ -284,6 +284,8 @@ class GraphBuilder(Generic[StateT, DepsT, GraphInputT, GraphOutputT]):
         async def wrapper(ctx: StepContext[StateT, DepsT, InputT]):
             return call(ctx)
 
+        node_id = node_id or get_callable_name(call)
+
         return self.step(call=wrapper, node_id=node_id, label=label)
 
     @overload
@@ -318,7 +320,7 @@ class GraphBuilder(Generic[StateT, DepsT, GraphInputT, GraphOutputT]):
         preferred_parent_fork: Literal['farthest', 'closest'] = 'farthest',
     ) -> Join[StateT, DepsT, InputT, OutputT]:
         if initial_factory is UNSET:
-            initial_factory = lambda: initial  # pyright: ignore[reportAssignmentType]  # noqa E731
+            initial_factory = lambda: initial  # pyright: ignore[reportAssignmentType]  # noqa: E731
 
         return Join[StateT, DepsT, InputT, OutputT](
             id=JoinID(NodeID(node_id or generate_placeholder_node_id(get_callable_name(reducer)))),
@@ -329,7 +331,7 @@ class GraphBuilder(Generic[StateT, DepsT, GraphInputT, GraphOutputT]):
         )
 
     # Edge building
-    def add(self, *edges: EdgePath[StateT, DepsT]) -> None:  # noqa C901
+    def add(self, *edges: EdgePath[StateT, DepsT]) -> None:  # noqa: C901
         """Add one or more edge paths to the graph.
 
         This method processes edge paths and automatically creates any necessary
@@ -674,7 +676,7 @@ class GraphBuilder(Generic[StateT, DepsT, GraphInputT, GraphOutputT]):
         )
 
 
-def _validate_graph_structure(  # noqa C901
+def _validate_graph_structure(  # noqa: C901
     nodes: dict[NodeID, AnyNode],
     edges_by_source: dict[NodeID, list[Path]],
 ) -> None:

{pydantic_graph-1.22.0 → pydantic_graph-1.34.0}/pydantic_graph/beta/mermaid.py

@@ -49,7 +49,7 @@ class MermaidEdge:
     label: str | None
 
 
-def build_mermaid_graph(  # noqa C901
+def build_mermaid_graph(  # noqa: C901
     graph_nodes: dict[NodeID, AnyNode], graph_edges_by_source: dict[NodeID, list[Path]]
 ) -> MermaidGraph:
     """Build a mermaid graph."""

{pydantic_graph-1.22.0 → pydantic_graph-1.34.0}/pydantic_graph/graph.py

@@ -167,7 +167,7 @@ class Graph(Generic[StateT, DepsT, RunEndT]):
     ) -> GraphRunResult[StateT, RunEndT]:
         """Synchronously run the graph.
 
-        This is a convenience method that wraps [`self.run`][pydantic_graph.Graph.run] with `loop.run_until_complete(...)`.
+        This is a convenience method that wraps [`self.run`][pydantic_graph.graph.Graph.run] with `loop.run_until_complete(...)`.
         You therefore can't use this method inside async code or if there's an active event loop.
 
         Args: