pydantic-ai 0.0.39__tar.gz → 0.0.40__tar.gz

{pydantic_ai-0.0.39 → pydantic_ai-0.0.40}/Makefile

@@ -49,11 +49,11 @@ test: ## Run tests and collect coverage data
 
 .PHONY: test-all-python
 test-all-python: ## Run tests on Python 3.9 to 3.13
-	UV_PROJECT_ENVIRONMENT=.venv39 uv run --python 3.9 --all-extras coverage run -p -m pytest
-	UV_PROJECT_ENVIRONMENT=.venv310 uv run --python 3.10 --all-extras coverage run -p -m pytest
-	UV_PROJECT_ENVIRONMENT=.venv311 uv run --python 3.11 --all-extras coverage run -p -m pytest
-	UV_PROJECT_ENVIRONMENT=.venv312 uv run --python 3.12 --all-extras coverage run -p -m pytest
-	UV_PROJECT_ENVIRONMENT=.venv313 uv run --python 3.13 --all-extras coverage run -p -m pytest
+	UV_PROJECT_ENVIRONMENT=.venv39 uv run --python 3.9 --all-extras --all-packages coverage run -p -m pytest
+	UV_PROJECT_ENVIRONMENT=.venv310 uv run --python 3.10 --all-extras --all-packages coverage run -p -m pytest
+	UV_PROJECT_ENVIRONMENT=.venv311 uv run --python 3.11 --all-extras --all-packages coverage run -p -m pytest
+	UV_PROJECT_ENVIRONMENT=.venv312 uv run --python 3.12 --all-extras --all-packages coverage run -p -m pytest
+	UV_PROJECT_ENVIRONMENT=.venv313 uv run --python 3.13 --all-extras --all-packages coverage run -p -m pytest
 	@uv run coverage combine
 	@uv run coverage report
 

{pydantic_ai-0.0.39 → pydantic_ai-0.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai
-Version: 0.0.39
+Version: 0.0.40
 Summary: Agent Framework / shim to use Pydantic with LLMs
 Project-URL: Homepage, https://ai.pydantic.dev
 Project-URL: Source, https://github.com/pydantic/pydantic-ai
@@ -28,9 +28,9 @@ Classifier: Topic :: Internet
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
-Requires-Dist: pydantic-ai-slim[anthropic,bedrock,cli,cohere,groq,mistral,openai,vertexai]==0.0.39
+Requires-Dist: pydantic-ai-slim[anthropic,bedrock,cli,cohere,groq,mistral,openai,vertexai]==0.0.40
 Provides-Extra: examples
-Requires-Dist: pydantic-ai-examples==0.0.39; extra == 'examples'
+Requires-Dist: pydantic-ai-examples==0.0.40; extra == 'examples'
 Provides-Extra: logfire
 Requires-Dist: logfire>=2.3; extra == 'logfire'
 Description-Content-Type: text/markdown

{pydantic_ai-0.0.39 → pydantic_ai-0.0.40}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai"
-version = "0.0.39"
+version = "0.0.40"
 description = "Agent Framework / shim to use Pydantic with LLMs"
 authors = [
     { name = "Samuel Colvin", email = "samuel@pydantic.dev" },
@@ -36,7 +36,7 @@ classifiers = [
 ]
 requires-python = ">=3.9"
 dependencies = [
-    "pydantic-ai-slim[openai,vertexai,groq,anthropic,mistral,cohere,bedrock,cli]==0.0.39",
+    "pydantic-ai-slim[openai,vertexai,groq,anthropic,mistral,cohere,bedrock,cli]==0.0.40",
 ]
 
 [project.urls]
@@ -46,7 +46,7 @@ Documentation = "https://ai.pydantic.dev"
 Changelog = "https://github.com/pydantic/pydantic-ai/releases"
 
 [project.optional-dependencies]
-examples = ["pydantic-ai-examples==0.0.39"]
+examples = ["pydantic-ai-examples==0.0.40"]
 logfire = ["logfire>=2.3"]
 
 [tool.uv.sources]

{pydantic_ai-0.0.39 → pydantic_ai-0.0.40}/tests/conftest.py

@@ -16,6 +16,7 @@ from typing import TYPE_CHECKING, Any, Callable
 import httpx
 import pytest
 from _pytest.assertion.rewrite import AssertionRewritingHook
+from pytest_mock import MockerFixture
 from typing_extensions import TypeAlias
 from vcr import VCR
 
@@ -44,17 +45,6 @@ else:
         return _IsNow(*args, **kwargs)
 
 
-try:
-    from logfire.testing import CaptureLogfire
-except ImportError:
-    pass
-else:
-
-    @pytest.fixture(autouse=True)
-    def logfire_disable(capfire: CaptureLogfire):
-        pass
-
-
 class TestEnv:
     __test__ = False
 
@@ -230,6 +220,12 @@ def image_content(assets_path: Path) -> BinaryContent:
     return BinaryContent(data=image_bytes, media_type='image/png')
 
 
+@pytest.fixture(scope='session')
+def document_content(assets_path: Path) -> BinaryContent:
+    pdf_bytes = assets_path.joinpath('dummy.pdf').read_bytes()
+    return BinaryContent(data=pdf_bytes, media_type='application/pdf')
+
+
 @pytest.fixture(scope='session')
 def openai_api_key() -> str:
     return os.getenv('OPENAI_API_KEY', 'mock-api-key')
@@ -248,3 +244,15 @@ def groq_api_key() -> str:
 @pytest.fixture(scope='session')
 def anthropic_api_key() -> str:
     return os.getenv('ANTHROPIC_API_KEY', 'mock-api-key')
+
+
+@pytest.fixture
+def mock_snapshot_id(mocker: MockerFixture):
+    i = 0
+
+    def generate_snapshot_id(node_id: str) -> str:
+        nonlocal i
+        i += 1
+        return f'{node_id}:{i}'
+
+    return mocker.patch('pydantic_graph.nodes.generate_snapshot_id', side_effect=generate_snapshot_id)

pydantic_ai-0.0.40/tests/graph/test_file_persistence.py

@@ -0,0 +1,204 @@
+from __future__ import annotations as _annotations
+
+from asyncio.exceptions import TimeoutError
+from dataclasses import dataclass
+from datetime import timezone
+from pathlib import Path
+from typing import Union
+
+import pytest
+from inline_snapshot import snapshot
+
+from pydantic_graph import (
+    BaseNode,
+    End,
+    EndSnapshot,
+    Graph,
+    GraphRunContext,
+    NodeSnapshot,
+)
+from pydantic_graph.persistence.file import FileStatePersistence
+
+from ..conftest import IsFloat, IsNow
+
+pytestmark = pytest.mark.anyio
+
+
+@dataclass
+class Float2String(BaseNode):
+    input_data: float
+
+    async def run(self, ctx: GraphRunContext) -> String2Length:
+        return String2Length(str(self.input_data))
+
+
+@dataclass
+class String2Length(BaseNode):
+    input_data: str
+
+    async def run(self, ctx: GraphRunContext) -> Double:
+        return Double(len(self.input_data))
+
+
+@dataclass
+class Double(BaseNode[None, None, int]):
+    input_data: int
+
+    async def run(self, ctx: GraphRunContext) -> Union[String2Length, End[int]]:  # noqa: UP007
+        if self.input_data == 7:  # pragma: no cover
+            return String2Length('x' * 21)
+        else:
+            return End(self.input_data * 2)
+
+
+async def test_run(tmp_path: Path, mock_snapshot_id: object):
+    my_graph = Graph(nodes=(Float2String, String2Length, Double))
+    p = tmp_path / 'test_graph.json'
+    persistence = FileStatePersistence(p)
+    result = await my_graph.run(Float2String(3.14), persistence=persistence)
+    # len('3.14') * 2 == 8
+    assert result.output == 8
+    assert my_graph.name == 'my_graph'
+    assert await persistence.load_all() == snapshot(
+        [
+            NodeSnapshot(
+                state=None,
+                node=Float2String(input_data=3.14),
+                start_ts=IsNow(tz=timezone.utc),
+                duration=IsFloat(),
+                status='success',
+                id='Float2String:1',
+            ),
+            NodeSnapshot(
+                state=None,
+                node=String2Length(input_data='3.14'),
+                start_ts=IsNow(tz=timezone.utc),
+                duration=IsFloat(),
+                status='success',
+                id='String2Length:2',
+            ),
+            NodeSnapshot(
+                state=None,
+                node=Double(input_data=4),
+                start_ts=IsNow(tz=timezone.utc),
+                duration=IsFloat(),
+                status='success',
+                id='Double:3',
+            ),
+            EndSnapshot(state=None, result=End(data=8), ts=IsNow(tz=timezone.utc), id='end:4'),
+        ]
+    )
+
+
+async def test_next_from_persistence(tmp_path: Path, mock_snapshot_id: object):
+    my_graph = Graph(nodes=(Float2String, String2Length, Double))
+    p = tmp_path / 'test_graph.json'
+    persistence = FileStatePersistence(p)
+
+    async with my_graph.iter(Float2String(3.14), persistence=persistence) as run:
+        node = await run.next()
+        assert node == snapshot(String2Length(input_data='3.14'))
+        assert node.get_snapshot_id() == snapshot('String2Length:2')
+        assert my_graph.name == 'my_graph'
+
+    async with my_graph.iter_from_persistence(persistence) as run:
+        node = await run.next()
+        assert node == snapshot(Double(input_data=4))
+        assert node.get_snapshot_id() == snapshot('Double:3')
+
+        node = await run.next()
+        assert node == snapshot(End(data=8))
+        assert node.get_snapshot_id() == snapshot('end:4')
+
+    assert await persistence.load_all() == snapshot(
+        [
+            NodeSnapshot(
+                state=None,
+                node=Float2String(input_data=3.14),
+                start_ts=IsNow(tz=timezone.utc),
+                duration=IsFloat(),
+                status='success',
+                id='Float2String:1',
+            ),
+            NodeSnapshot(
+                state=None,
+                node=String2Length(input_data='3.14'),
+                start_ts=IsNow(tz=timezone.utc),
+                duration=IsFloat(),
+                status='success',
+                id='String2Length:2',
+            ),
+            NodeSnapshot(
+                state=None,
+                node=Double(input_data=4),
+                start_ts=IsNow(tz=timezone.utc),
+                duration=IsFloat(),
+                status='success',
+                id='Double:3',
+            ),
+            EndSnapshot(state=None, result=End(data=8), ts=IsNow(tz=timezone.utc), id='end:4'),
+        ]
+    )
+
+
+async def test_node_error(tmp_path: Path, mock_snapshot_id: object):
+    @dataclass
+    class Foo(BaseNode):
+        async def run(self, ctx: GraphRunContext) -> Bar:
+            return Bar()
+
+    @dataclass
+    class Bar(BaseNode[None, None, None]):
+        async def run(self, ctx: GraphRunContext) -> End[None]:
+            raise RuntimeError('test error')
+
+    g = Graph(nodes=(Foo, Bar))
+    p = tmp_path / 'test_graph.json'
+    persistence = FileStatePersistence(p)
+    with pytest.raises(RuntimeError, match='test error'):
+        await g.run(Foo(), persistence=persistence)
+
+    assert await persistence.load_all() == snapshot(
+        [
+            NodeSnapshot(
+                state=None,
+                node=Foo(),
+                start_ts=IsNow(tz=timezone.utc),
+                duration=IsFloat(),
+                status='success',
+                id='Foo:1',
+            ),
+            NodeSnapshot(
+                state=None,
+                node=Bar(),
+                start_ts=IsNow(tz=timezone.utc),
+                duration=IsFloat(),
+                status='error',
+                id='Bar:2',
+            ),
+        ]
+    )
+
+
+async def test_lock_timeout(tmp_path: Path):
+    p = tmp_path / 'test_graph.json'
+    persistence = FileStatePersistence(p)
+    async with persistence._lock():  # type: ignore[reportPrivateUsage]
+        pass
+
+    async with persistence._lock():  # type: ignore[reportPrivateUsage]
+        with pytest.raises(TimeoutError):
+            async with persistence._lock(timeout=0.1):  # type: ignore[reportPrivateUsage]
+                pass
+
+
+async def test_record_lookup_error(tmp_path: Path):
+    p = tmp_path / 'test_graph.json'
+    persistence = FileStatePersistence(p)
+    my_graph = Graph(nodes=(Float2String, String2Length, Double))
+    persistence.set_graph_types(my_graph)
+    persistence.set_graph_types(my_graph)
+
+    with pytest.raises(LookupError, match="No snapshot found with id='foobar'"):
+        async with persistence.record_run('foobar'):
+            pass