more tests, improve coverage

pydantic · samuelcolvin · Mar 14, 2025 · Feb 19, 2025 · Feb 23, 2025 · Feb 24, 2025
commit e271af50b01cfc6dfde795c755d1fe9fa34a0bfd
diff --git a/pydantic_graph/pydantic_graph/_utils.py b/pydantic_graph/pydantic_graph/_utils.py
@@ -2,10 +2,9 @@
 
 import asyncio
 import types
-from functools import partial
-from typing import Any, Callable, TypeVar
+from typing import Any, TypeVar
 
-from typing_extensions import ParamSpec, TypeIs, get_args, get_origin
+from typing_extensions import TypeIs, get_args, get_origin
 from typing_inspection import typing_objects
 from typing_inspection.introspection import is_union_origin
 
@@ -88,15 +87,3 @@ class Unset:
 
 def is_set(t_or_unset: T | Unset) -> TypeIs[T]:
     return t_or_unset is not UNSET
-
-
-_P = ParamSpec('_P')
-_R = TypeVar('_R')
-
-
-async def run_in_executor(func: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs) -> _R:
-    if kwargs:
-        # noinspection PyTypeChecker
-        return await asyncio.get_running_loop().run_in_executor(None, partial(func, *args, **kwargs))
-    else:
-        return await asyncio.get_running_loop().run_in_executor(None, func, *args)  # type: ignore
diff --git a/pydantic_graph/pydantic_graph/graph.py b/pydantic_graph/pydantic_graph/graph.py
@@ -247,7 +247,9 @@ async def iter(
             A GraphRun that can be async iterated over to drive the graph to completion.
         """
         if infer_name and self.name is None:
-            self._infer_name(inspect.currentframe())
+            # f_back because `asynccontextmanager` adds one frame
+            if frame := inspect.currentframe():  # pragma: no branch
+                self._infer_name(frame.f_back)
 
         if persistence is None:
             persistence = SimpleStatePersistence()
@@ -725,8 +727,7 @@ async def __anext__(self) -> BaseNode[StateT, DepsT, RunEndT] | End[RunEndT]:
         return await self.next(self._next_node)
 
     def __repr__(self) -> str:
-        step = -1  # TODO
-        return f'<GraphRun name={self.graph.name or "<unnamed>"} step={step}>'
+        return f'<GraphRun graph={self.graph.name or "[unnamed]"}>'
 
 
 @dataclass

diff --git a/tests/graph/test_graph.py b/tests/graph/test_graph.py
@@ -298,6 +298,22 @@ async def run(self, ctx: GraphRunContext) -> End[None]:
     assert exc_info.value.message == snapshot('Invalid node return type: `int`. Expected `BaseNode` or `End`.')
 
 
+async def test_iter():
+    my_graph = Graph(nodes=(Float2String, String2Length, Double))
+    assert my_graph.name is None
+    assert my_graph._inferred_types == (type(None), int)
+    node_reprs: list[str] = []
+    async with my_graph.iter(Float2String(3.14)) as graph_iter:
+        assert repr(graph_iter) == snapshot('<GraphRun graph=my_graph>')
+        async for node in graph_iter:
+            node_reprs.append(repr(node))
+        # len('3.14') * 2 == 8
+        assert graph_iter.result
+        assert graph_iter.result.output == 8
+
+    assert node_reprs == snapshot(["String2Length(input_data='3.14')", 'Double(input_data=4)', 'End(data=8)'])
+
+
 async def test_next(mock_snapshot_id: object):
     @dataclass
     class Foo(BaseNode):

diff --git a/tests/graph/test_persistence.py b/tests/graph/test_persistence.py
@@ -163,7 +163,7 @@ def test_one_node(mock_snapshot_id: object):
     class MyNode(BaseNode[None, None, int]):
         node_field: int
 
-        async def run(self, ctx: GraphRunContext) -> End[int]:
+        async def run(self, ctx: GraphRunContext) -> End[int]:  # pragma: no cover
             return End(123)
 
     g = Graph(nodes=[MyNode])
@@ -196,7 +196,7 @@ async def run(self, ctx: GraphRunContext) -> End[int]:
 def test_no_generic_arg(mock_snapshot_id: object):
     @dataclass
     class NoGenericArgsNode(BaseNode):
-        async def run(self, ctx: GraphRunContext) -> NoGenericArgsNode:
+        async def run(self, ctx: GraphRunContext) -> NoGenericArgsNode:  # pragma: no cover
             return NoGenericArgsNode()
 
     g = Graph(nodes=[NoGenericArgsNode])