pydantic-ai 0.0.24__tar.gz → 0.0.26__tar.gz

{pydantic_ai-0.0.24 → pydantic_ai-0.0.26}/Makefile

@@ -64,7 +64,11 @@ testcov: test ## Run tests and generate a coverage report
 
 .PHONY: update-examples
 update-examples: ## Update documentation examples
-	uv run -m pytest --update-examples
+	uv run -m pytest --update-examples tests/test_examples.py
+
+.PHONY: update-vcr-tests
+update-vcr-tests: ## Update tests using VCR that hit LLM APIs; note you'll need to set API keys as appropriate
+	uv run -m pytest --record-mode=rewrite tests
 
 # `--no-strict` so you can build the docs without insiders packages
 .PHONY: docs

{pydantic_ai-0.0.24 → pydantic_ai-0.0.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai
-Version: 0.0.24
+Version: 0.0.26
 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
@@ -10,17 +10,12 @@ Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
 License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
-Classifier: Environment :: MacOS X
 Classifier: Framework :: Pydantic
 Classifier: Framework :: Pydantic :: 2
-Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
-Classifier: Intended Audience :: System Administrators
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Operating System :: Unix
+Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -30,11 +25,12 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 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,cohere,groq,mistral,openai,vertexai]==0.0.24
+Requires-Dist: pydantic-ai-slim[anthropic,cohere,groq,mistral,openai,vertexai]==0.0.26
 Provides-Extra: examples
-Requires-Dist: pydantic-ai-examples==0.0.24; extra == 'examples'
+Requires-Dist: pydantic-ai-examples==0.0.26; extra == 'examples'
 Provides-Extra: logfire
 Requires-Dist: logfire>=2.3; extra == 'logfire'
 Description-Content-Type: text/markdown

{pydantic_ai-0.0.24 → pydantic_ai-0.0.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai"
-version = "0.0.24"
+version = "0.0.26"
 description = "Agent Framework / shim to use Pydantic with LLMs"
 authors = [
     { name = "Samuel Colvin", email = "samuel@pydantic.dev" },
@@ -23,21 +23,17 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Intended Audience :: Developers",
     "Intended Audience :: Information Technology",
-    "Intended Audience :: System Administrators",
     "License :: OSI Approved :: MIT License",
-    "Operating System :: Unix",
-    "Operating System :: POSIX :: Linux",
-    "Environment :: Console",
-    "Environment :: MacOS X",
-    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Operating System :: OS Independent",
     "Topic :: Internet",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
     "Framework :: Pydantic",
     "Framework :: Pydantic :: 2",
-    "Framework :: Pytest",
 ]
 requires-python = ">=3.9"
 
-dependencies = ["pydantic-ai-slim[openai,vertexai,groq,anthropic,mistral,cohere]==0.0.24"]
+dependencies = ["pydantic-ai-slim[openai,vertexai,groq,anthropic,mistral,cohere]==0.0.26"]
 
 [project.urls]
 Homepage = "https://ai.pydantic.dev"
@@ -46,7 +42,7 @@ Documentation = "https://ai.pydantic.dev"
 Changelog = "https://github.com/pydantic/pydantic-ai/releases"
 
 [project.optional-dependencies]
-examples = ["pydantic-ai-examples==0.0.24"]
+examples = ["pydantic-ai-examples==0.0.26"]
 logfire = ["logfire>=2.3"]
 
 [tool.uv.sources]
@@ -61,7 +57,7 @@ members = ["pydantic_ai_slim", "pydantic_graph", "examples"]
 # dev dependencies are defined in `pydantic-ai-slim/pyproject.toml` to allow for minimal testing
 lint = [
     "mypy>=1.11.2",
-    "pyright>=1.1.388",
+    "pyright>=1.1.388,<1.1.390",
     "ruff>=0.6.9",
 ]
 docs = [
@@ -193,4 +189,4 @@ skip = '.git*,*.svg,*.lock,*.css'
 check-hidden = true
 # Ignore "formatting" like **L**anguage
 ignore-regex = '\*\*[A-Z]\*\*[a-z]+\b'
-# ignore-words-list = ''
+ignore-words-list = 'asend'

{pydantic_ai-0.0.24 → pydantic_ai-0.0.26}/tests/conftest.py

@@ -17,20 +17,25 @@ import httpx
 import pytest
 from _pytest.assertion.rewrite import AssertionRewritingHook
 from typing_extensions import TypeAlias
+from vcr import VCR
 
 import pydantic_ai.models
+from pydantic_ai.messages import BinaryContent
+from pydantic_ai.models import cached_async_http_client
 
-__all__ = 'IsNow', 'IsFloat', 'TestEnv', 'ClientWithHandler', 'try_import'
+__all__ = 'IsDatetime', 'IsFloat', 'IsNow', 'IsStr', 'TestEnv', 'ClientWithHandler', 'try_import'
 
 
 pydantic_ai.models.ALLOW_MODEL_REQUESTS = False
 
 if TYPE_CHECKING:
 
-    def IsNow(*args: Any, **kwargs: Any) -> datetime: ...
+    def IsDatetime(*args: Any, **kwargs: Any) -> datetime: ...
     def IsFloat(*args: Any, **kwargs: Any) -> float: ...
+    def IsNow(*args: Any, **kwargs: Any) -> datetime: ...
+    def IsStr(*args: Any, **kwargs: Any) -> str: ...
 else:
-    from dirty_equals import IsFloat, IsNow as _IsNow
+    from dirty_equals import IsDatetime, IsFloat, IsNow as _IsNow, IsStr
 
     def IsNow(*args: Any, **kwargs: Any):
         # Increase the default value of `delta` to 10 to reduce test flakiness on overburdened machines
@@ -179,3 +184,61 @@ def set_event_loop() -> Iterator[None]:
     asyncio.set_event_loop(new_loop)
     yield
     new_loop.close()
+
+
+def pytest_recording_configure(config: Any, vcr: VCR):
+    from . import json_body_serializer
+
+    vcr.register_serializer('yaml', json_body_serializer)
+
+
+@pytest.fixture(scope='module')
+def vcr_config():
+    return {
+        # Note: additional header filtering is done inside the serializer
+        'filter_headers': ['authorization', 'x-api-key'],
+        'decode_compressed_response': True,
+    }
+
+
+@pytest.fixture(autouse=True)
+async def close_cached_httpx_client() -> AsyncIterator[None]:
+    yield
+    await cached_async_http_client().aclose()
+
+
+@pytest.fixture(scope='session')
+def assets_path() -> Path:
+    return Path(__file__).parent / 'assets'
+
+
+@pytest.fixture(scope='session')
+def audio_content(assets_path: Path) -> BinaryContent:
+    audio_bytes = assets_path.joinpath('marcelo.mp3').read_bytes()
+    return BinaryContent(data=audio_bytes, media_type='audio/mpeg')
+
+
+@pytest.fixture(scope='session')
+def image_content(assets_path: Path) -> BinaryContent:
+    image_bytes = assets_path.joinpath('kiwi.png').read_bytes()
+    return BinaryContent(data=image_bytes, media_type='image/png')
+
+
+@pytest.fixture(scope='session')
+def openai_api_key() -> str:
+    return os.getenv('OPENAI_API_KEY', 'mock-api-key')
+
+
+@pytest.fixture(scope='session')
+def gemini_api_key() -> str:
+    return os.getenv('GEMINI_API_KEY', 'mock-api-key')
+
+
+@pytest.fixture(scope='session')
+def groq_api_key() -> str:
+    return os.getenv('GROQ_API_KEY', 'mock-api-key')
+
+
+@pytest.fixture(scope='session')
+def anthropic_api_key() -> str:
+    return os.getenv('ANTHROPIC_API_KEY', 'mock-api-key')

{pydantic_ai-0.0.24 → pydantic_ai-0.0.26}/tests/graph/test_graph.py

@@ -57,11 +57,11 @@ async def test_graph():
     assert my_graph.name is None
     assert my_graph._get_state_type() is type(None)
     assert my_graph._get_run_end_type() is int
-    result, history = await my_graph.run(Float2String(3.14))
+    result = await my_graph.run(Float2String(3.14))
     # len('3.14') * 2 == 8
-    assert result == 8
+    assert result.output == 8
     assert my_graph.name == 'my_graph'
-    assert history == snapshot(
+    assert result.history == snapshot(
         [
             NodeStep(
                 state=None,
@@ -84,10 +84,10 @@ async def test_graph():
             EndStep(result=End(data=8), ts=IsNow(tz=timezone.utc)),
         ]
     )
-    result, history = await my_graph.run(Float2String(3.14159))
+    result = await my_graph.run(Float2String(3.14159))
     # len('3.14159') == 7, 21 * 2 == 42
-    assert result == 42
-    assert history == snapshot(
+    assert result.output == 42
+    assert result.history == snapshot(
         [
             NodeStep(
                 state=None,
@@ -122,7 +122,7 @@ async def test_graph():
             EndStep(result=End(data=42), ts=IsNow(tz=timezone.utc)),
         ]
     )
-    assert [e.data_snapshot() for e in history] == snapshot(
+    assert [e.data_snapshot() for e in result.history] == snapshot(
         [
             Float2String(input_data=3.14159),
             String2Length(input_data='3.14159'),
@@ -320,10 +320,10 @@ async def test_deps():
             return End(123)
 
     g = Graph(nodes=(Foo, Bar))
-    result, history = await g.run(Foo(), deps=Deps(1, 2))
+    result = await g.run(Foo(), deps=Deps(1, 2))
 
-    assert result == 123
-    assert history == snapshot(
+    assert result.output == 123
+    assert result.history == snapshot(
         [
             NodeStep(state=None, node=Foo(), start_ts=IsNow(tz=timezone.utc), duration=IsFloat()),
             NodeStep(state=None, node=Bar(), start_ts=IsNow(tz=timezone.utc), duration=IsFloat()),

{pydantic_ai-0.0.24 → pydantic_ai-0.0.26}/tests/graph/test_history.py

@@ -46,16 +46,17 @@ class Bar(BaseNode[MyState, None, int]):
     ],
 )
 async def test_dump_load_history(graph: Graph[MyState, None, int]):
-    result, history = await graph.run(Foo(), state=MyState(1, ''))
-    assert result == snapshot(4)
-    assert history == snapshot(
+    result = await graph.run(Foo(), state=MyState(1, ''))
+    assert result.output == snapshot(4)
+    assert result.state == snapshot(MyState(x=2, y='y'))
+    assert result.history == snapshot(
         [
             NodeStep(state=MyState(x=2, y=''), node=Foo(), start_ts=IsNow(tz=timezone.utc), duration=IsFloat()),
             NodeStep(state=MyState(x=2, y='y'), node=Bar(), start_ts=IsNow(tz=timezone.utc), duration=IsFloat()),
-            EndStep(result=End(4), ts=IsNow(tz=timezone.utc)),
+            EndStep(result=End(data=4), ts=IsNow(tz=timezone.utc)),
         ]
     )
-    history_json = graph.dump_history(history)
+    history_json = graph.dump_history(result.history)
     assert json.loads(history_json) == snapshot(
         [
             {
@@ -76,7 +77,7 @@ async def test_dump_load_history(graph: Graph[MyState, None, int]):
         ]
     )
     history_loaded = graph.load_history(history_json)
-    assert history == history_loaded
+    assert result.history == history_loaded
 
     custom_history = [
         {

{pydantic_ai-0.0.24 → pydantic_ai-0.0.26}/tests/graph/test_mermaid.py

@@ -58,9 +58,9 @@ graph2 = Graph(nodes=(Spam, Foo, Bar, Eggs))
 
 
 async def test_run_graph():
-    result, history = await graph1.run(Foo())
-    assert result is None
-    assert history == snapshot(
+    result = await graph1.run(Foo())
+    assert result.output is None
+    assert result.history == snapshot(
         [
             NodeStep(
                 state=None,

{pydantic_ai-0.0.24 → pydantic_ai-0.0.26}/tests/graph/test_state.py

@@ -36,9 +36,9 @@ async def test_run_graph():
     assert graph._get_state_type() is MyState
     assert graph._get_run_end_type() is str
     state = MyState(1, '')
-    result, history = await graph.run(Foo(), state=state)
-    assert result == snapshot('x=2 y=y')
-    assert history == snapshot(
+    result = await graph.run(Foo(), state=state)
+    assert result.output == snapshot('x=2 y=y')
+    assert result.history == snapshot(
         [
             NodeStep(
                 state=MyState(x=2, y=''),
@@ -52,7 +52,7 @@ async def test_run_graph():
                 start_ts=IsNow(tz=timezone.utc),
                 duration=IsFloat(),
             ),
-            EndStep(result=End('x=2 y=y'), ts=IsNow(tz=timezone.utc)),
+            EndStep(result=End(data='x=2 y=y'), ts=IsNow(tz=timezone.utc)),
         ]
     )
     assert state == MyState(x=2, y='y')

pydantic_ai-0.0.26/tests/json_body_serializer.py

@@ -0,0 +1,77 @@
+# pyright: reportUnknownMemberType=false, reportUnknownVariableType=false
+import json
+from typing import TYPE_CHECKING, Any
+
+import yaml
+
+if TYPE_CHECKING:
+    from yaml import Dumper, Loader
+else:
+    try:
+        from yaml import CDumper as Dumper, CLoader as Loader
+    except ImportError:
+        from yaml import Dumper, Loader
+
+FILTERED_HEADER_PREFIXES = ['anthropic-', 'cf-', 'x-']
+FILTERED_HEADERS = {'authorization', 'date', 'request-id', 'server', 'user-agent', 'via', 'set-cookie'}
+
+
+class LiteralDumper(Dumper):
+    """
+    A custom dumper that will represent multi-line strings using literal style.
+    """
+
+
+def str_presenter(dumper: Dumper, data: str):
+    """If the string contains newlines, represent it as a literal block."""
+    if '\n' in data:
+        return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|')
+    return dumper.represent_scalar('tag:yaml.org,2002:str', data)
+
+
+# Register the custom presenter on our dumper
+LiteralDumper.add_representer(str, str_presenter)
+
+
+def deserialize(cassette_string: str):
+    cassette_dict = yaml.load(cassette_string, Loader=Loader)
+    for interaction in cassette_dict['interactions']:
+        for kind, data in interaction.items():
+            parsed_body = data.pop('parsed_body', None)
+            if parsed_body is not None:
+                dumped_body = json.dumps(parsed_body)
+                data['body'] = {'string': dumped_body} if kind == 'response' else dumped_body
+    return cassette_dict
+
+
+def serialize(cassette_dict: Any):
+    for interaction in cassette_dict['interactions']:
+        for _kind, data in interaction.items():
+            headers: dict[str, list[str]] = data.get('headers', {})
+            # make headers lowercase
+            headers = {k.lower(): v for k, v in headers.items()}
+            # filter headers by name
+            headers = {k: v for k, v in headers.items() if k not in FILTERED_HEADERS}
+            # filter headers by prefix
+            headers = {
+                k: v for k, v in headers.items() if not any(k.startswith(prefix) for prefix in FILTERED_HEADER_PREFIXES)
+            }
+            # update headers on source object
+            data['headers'] = headers
+
+            content_type = headers.get('content-type', None)
+            if content_type != ['application/json']:
+                continue
+
+            # Parse the body as JSON
+            body: Any = data.get('body', None)
+            assert body is not None, data
+            if isinstance(body, dict):
+                # Responses will have the body under a field called 'string'
+                body = body.get('string')
+            if body is not None:
+                data['parsed_body'] = json.loads(body)
+                del data['body']
+
+    # Use our custom dumper
+    return yaml.dump(cassette_dict, Dumper=LiteralDumper, allow_unicode=True, width=120)