add test to make sure runner overloads are in sync (#1414)

* add ability to test overloads are in sync on tool runner

* formt

* fix

* use typing_extensions.get_overloads() for broader python version support

Co-Authored-By: Claude Code (${CLAUDE_PROJECT_DIR}) <noreply@anthropic.com>

* fix import ordering for ruff

Co-Authored-By: Claude Code (${CLAUDE_PROJECT_DIR}) <noreply@anthropic.com>

* Update tests/lib/streaming/test_beta_messages.py

Co-authored-by: Robert Craigie <robert@craigie.dev>

* format

* format again

---------

Co-authored-by: Claude Code (${CLAUDE_PROJECT_DIR}) <noreply@anthropic.com>
Co-authored-by: Robert Craigie <robert@craigie.dev>

Author: 3 people

src/anthropic/_utils/__init__.py

@@ -60,6 +60,7 @@
 )
 from ._reflection import (
     function_has_argument as function_has_argument,
+    assert_overloads_in_sync as assert_overloads_in_sync,
     assert_signatures_in_sync as assert_signatures_in_sync,
 )
 from ._datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime

src/anthropic/_utils/_reflection.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import inspect
+import typing_extensions
 from typing import Any, Callable
 
 
@@ -40,3 +41,40 @@ def assert_signatures_in_sync(
 
     if errors:
         raise AssertionError(f"{len(errors)} errors encountered when comparing signatures:\n\n" + "\n\n".join(errors))
+
+
+def assert_overloads_in_sync(
+    source_func: Callable[..., Any],
+    overloaded_func: Callable[..., Any],
+    *,
+    exclude_params: set[str] = set(),
+) -> None:
+    """Ensure that every @overload of overloaded_func contains all params from source_func."""
+    source_sig = inspect.signature(source_func)
+    overloads = typing_extensions.get_overloads(overloaded_func)
+
+    if not overloads:
+        raise AssertionError(f"No @overload definitions found for {overloaded_func!r}")
+
+    errors: list[str] = []
+
+    for i, overload_fn in enumerate(overloads):
+        overload_sig = inspect.signature(overload_fn)
+        for name, source_param in source_sig.parameters.items():
+            if name in exclude_params:
+                continue
+
+            overload_param = overload_sig.parameters.get(name)
+            if not overload_param:
+                errors.append(f"overload {i}: `{name}` param is missing")
+                continue
+
+            if overload_param.annotation != source_param.annotation:
+                errors.append(
+                    f"overload {i}: types for `{name}` do not match; source={repr(source_param.annotation)} overload={repr(overload_param.annotation)}"
+                )
+
+    if errors:
+        raise AssertionError(
+            f"{len(errors)} errors encountered when comparing overload signatures:\n\n" + "\n\n".join(errors)
+        )

src/anthropic/lib/_parse/_transform.py

@@ -112,7 +112,7 @@ def transform_schema(
 
     enum = json_schema.pop("enum", None)
     if is_list(enum):
-        strict_schema['enum'] = enum
+        strict_schema["enum"] = enum
 
     description = json_schema.pop("description", None)
     if description is not None:

src/anthropic/resources/beta/messages/batches.py

@@ -406,9 +406,7 @@ def results(
         }
         extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
         return self._get(
-            path_template(
-                batch.results_url, message_batch_id=message_batch_id
-            ),
+            path_template(batch.results_url, message_batch_id=message_batch_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -797,9 +795,7 @@ async def results(
         }
         extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
         return await self._get(
-            path_template(
-                batch.results_url, message_batch_id=message_batch_id
-            ),
+            path_template(batch.results_url, message_batch_id=message_batch_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),

tests/lib/streaming/test_beta_messages.py

@@ -2,7 +2,6 @@
 
 import os
 import json
-import inspect
 from typing import Any, Set, Dict, TypeVar, cast
 from unittest import TestCase
 
@@ -11,6 +10,7 @@
 from respx import MockRouter
 
 from anthropic import Anthropic, AsyncAnthropic
+from anthropic._utils import assert_overloads_in_sync, assert_signatures_in_sync
 from anthropic._compat import PYDANTIC_V1
 from anthropic.types.beta.beta_message import BetaMessage
 from anthropic.lib.streaming._beta_types import ParsedBetaMessageStreamEvent
@@ -376,36 +376,31 @@ async def test_incomplete_response(self, respx_mock: MockRouter) -> None:
 @pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"])
 def test_stream_method_definition_in_sync(sync: bool) -> None:
     client: Anthropic | AsyncAnthropic = sync_client if sync else async_client
+    assert_signatures_in_sync(
+        client.beta.messages.create,
+        client.beta.messages.stream,
+        exclude_params={"stream", "output_format"},
+    )
 
-    sig = inspect.signature(client.beta.messages.stream)
-    generated_sig = inspect.signature(client.beta.messages.create)
-
-    errors: list[str] = []
-
-    for name, generated_param in generated_sig.parameters.items():
-        if name == "stream":
-            # intentionally excluded
-            continue
-
-        if name == "output_format":
-            continue
 
-        custom_param = sig.parameters.get(name)
-        if not custom_param:
-            errors.append(f"the `{name}` param is missing")
-            continue
+@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"])
+def test_parse_method_definition_in_sync(sync: bool) -> None:
+    client: Anthropic | AsyncAnthropic = sync_client if sync else async_client
+    assert_signatures_in_sync(
+        client.beta.messages.create,
+        client.beta.messages.parse,
+        exclude_params={"stream", "output_format"},
+    )
 
-        if custom_param.annotation != generated_param.annotation:
-            errors.append(
-                f"types for the `{name}` param are do not match; generated={repr(generated_param.annotation)} custom={repr(custom_param.annotation)}"
-            )
-            continue
 
-    if errors:
-        raise AssertionError(
-            f"{len(errors)} errors encountered with the {'sync' if sync else 'async'} client `messages.stream()` method:\n\n"
-            + "\n\n".join(errors)
-        )
+@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"])
+def test_tool_runner_method_definition_in_sync(sync: bool) -> None:
+    client: Anthropic | AsyncAnthropic = sync_client if sync else async_client
+    assert_overloads_in_sync(
+        client.beta.messages.create,
+        client.beta.messages.tool_runner,
+        exclude_params={"stream", "tools", "max_iterations", "compaction_control", "output_format"},
+    )
 
 
 # go through all the ContentBlock types to make sure the type alias is up to date

tests/lib/streaming/test_messages.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 import os
-import inspect
 from typing import Any, Set, TypeVar, cast
 
 import httpx
 import pytest
 from respx import MockRouter
 
 from anthropic import Stream, Anthropic, AsyncStream, AsyncAnthropic
+from anthropic._utils import assert_signatures_in_sync
 from anthropic._compat import PYDANTIC_V1
 from anthropic.lib.streaming import ParsedMessageStreamEvent
 from anthropic.types.message import Message
@@ -274,33 +274,11 @@ async def test_tool_use(self, respx_mock: MockRouter) -> None:
 @pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"])
 def test_stream_method_definition_in_sync(sync: bool) -> None:
     client: Anthropic | AsyncAnthropic = sync_client if sync else async_client
-
-    sig = inspect.signature(client.messages.stream)
-    generated_sig = inspect.signature(client.messages.create)
-
-    errors: list[str] = []
-
-    for name, generated_param in generated_sig.parameters.items():
-        if name == "stream":
-            # intentionally excluded
-            continue
-
-        custom_param = sig.parameters.get(name)
-        if not custom_param:
-            errors.append(f"the `{name}` param is missing")
-            continue
-
-        if custom_param.annotation != generated_param.annotation:
-            errors.append(
-                f"types for the `{name}` param are do not match; generated={repr(generated_param.annotation)} custom={repr(custom_param.annotation)}"
-            )
-            continue
-
-    if errors:
-        raise AssertionError(
-            f"{len(errors)} errors encountered with the {'sync' if sync else 'async'} client `messages.stream()` method:\n\n"
-            + "\n\n".join(errors)
-        )
+    assert_signatures_in_sync(
+        client.messages.create,
+        client.messages.stream,
+        exclude_params={"stream"},
+    )
 
 
 # go through all the ContentBlock types to make sure the type alias is up to date