chore!: anthropic - drop Python 3.9 and use X|Y typing (#2688)

Author: anakin87

integrations/anthropic/pyproject.toml

@@ -7,23 +7,22 @@ name = "anthropic-haystack"
 dynamic = ["version"]
 description = 'An integration of Anthropic Claude models into the Haystack framework.'
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = "Apache-2.0"
 keywords = []
 authors = [{ name = "deepset GmbH", email = "info@deepset.ai" }]
 classifiers = [
   "License :: OSI Approved :: Apache Software License",
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.19.0", "anthropic>=0.47.0"]
+dependencies = ["haystack-ai>=2.22.0", "anthropic>=0.47.0"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/anthropic#readme"
@@ -77,7 +76,6 @@ disallow_incomplete_defs = true
 
 
 [tool.ruff]
-target-version = "py39"
 line-length = 120
 
 [tool.ruff.lint]
@@ -126,10 +124,6 @@ ignore = [
   "ARG002",
   "ARG005",
 ]
-unfixable = [
-  # Don't touch unused imports
-  "F401",
-]
 
 [tool.ruff.lint.isort]
 known-first-party = ["haystack_integrations"]

integrations/anthropic/src/haystack_integrations/components/generators/anthropic/chat/chat_generator.py

@@ -1,5 +1,5 @@
 from datetime import datetime, timezone
-from typing import Any, ClassVar, Optional, Union
+from typing import Any, ClassVar
 
 from haystack import component, default_from_dict, default_to_dict, logging
 from haystack.components.generators.utils import _convert_streaming_chunks_to_chat_message
@@ -113,13 +113,13 @@ def __init__(
         self,
         api_key: Secret = Secret.from_env_var("ANTHROPIC_API_KEY"),  # noqa: B008
         model: str = "claude-sonnet-4-5",
-        streaming_callback: Optional[StreamingCallbackT] = None,
-        generation_kwargs: Optional[dict[str, Any]] = None,
+        streaming_callback: StreamingCallbackT | None = None,
+        generation_kwargs: dict[str, Any] | None = None,
         ignore_tools_thinking_messages: bool = True,
-        tools: Optional[ToolsType] = None,
+        tools: ToolsType | None = None,
         *,
-        timeout: Optional[float] = None,
-        max_retries: Optional[int] = None,
+        timeout: float | None = None,
+        max_retries: int | None = None,
     ):
         """
         Creates an instance of AnthropicChatGenerator.
@@ -229,8 +229,8 @@ def from_dict(cls, data: dict[str, Any]) -> "AnthropicChatGenerator":
     def _prepare_request_params(
         self,
         messages: list[ChatMessage],
-        generation_kwargs: Optional[dict[str, Any]] = None,
-        tools: Optional[ToolsType] = None,
+        generation_kwargs: dict[str, Any] | None = None,
+        tools: ToolsType | None = None,
     ) -> tuple[list[TextBlockParam], list[MessageParam], dict[str, Any], list[ToolParam]]:
         """
         Prepare the parameters for the Anthropic API request.
@@ -277,8 +277,8 @@ def _prepare_request_params(
 
     def _process_response(
         self,
-        response: Union[Message, Stream[RawMessageStreamEvent]],
-        streaming_callback: Optional[SyncStreamingCallbackT] = None,
+        response: Message | Stream[RawMessageStreamEvent],
+        streaming_callback: SyncStreamingCallbackT | None = None,
     ) -> dict[str, list[ChatMessage]]:
         """
         Process the response from the Anthropic API.
@@ -291,7 +291,7 @@ def _process_response(
         # we cannot use isinstance(Stream)
         if not isinstance(response, Message):
             chunks: list[StreamingChunk] = []
-            model: Optional[str] = None
+            model: str | None = None
             tool_call_index = -1
             input_tokens = None
             component_info = ComponentInfo.from_component(self)
@@ -345,7 +345,7 @@ def _process_response(
     async def _process_response_async(
         self,
         response: Any,
-        streaming_callback: Optional[AsyncStreamingCallbackT] = None,
+        streaming_callback: AsyncStreamingCallbackT | None = None,
     ) -> dict[str, list[ChatMessage]]:
         """
         Process the response from the Anthropic API asynchronously.
@@ -359,7 +359,7 @@ async def _process_response_async(
         # workaround for https://github.com/DataDog/dd-trace-py/issues/12562
         if not isinstance(response, Message):
             chunks: list[StreamingChunk] = []
-            model: Optional[str] = None
+            model: str | None = None
             tool_call_index = -1
             input_tokens = None
             component_info = ComponentInfo.from_component(self)
@@ -418,9 +418,9 @@ async def _process_response_async(
     def run(
         self,
         messages: list[ChatMessage],
-        streaming_callback: Optional[StreamingCallbackT] = None,
-        generation_kwargs: Optional[dict[str, Any]] = None,
-        tools: Optional[ToolsType] = None,
+        streaming_callback: StreamingCallbackT | None = None,
+        generation_kwargs: dict[str, Any] | None = None,
+        tools: ToolsType | None = None,
     ) -> dict[str, list[ChatMessage]]:
         """
         Invokes the Anthropic API with the given messages and generation kwargs.
@@ -460,9 +460,9 @@ def run(
     async def run_async(
         self,
         messages: list[ChatMessage],
-        streaming_callback: Optional[StreamingCallbackT] = None,
-        generation_kwargs: Optional[dict[str, Any]] = None,
-        tools: Optional[ToolsType] = None,
+        streaming_callback: StreamingCallbackT | None = None,
+        generation_kwargs: dict[str, Any] | None = None,
+        tools: ToolsType | None = None,
     ) -> dict[str, list[ChatMessage]]:
         """
         Async version of the run method. Invokes the Anthropic API with the given messages and generation kwargs.

integrations/anthropic/src/haystack_integrations/components/generators/anthropic/chat/utils.py

@@ -1,4 +1,4 @@
-from typing import Any, Literal, Optional, Union, cast, get_args
+from typing import Any, Literal, cast, get_args
 
 from haystack.dataclasses.chat_message import (
     ChatMessage,
@@ -46,14 +46,12 @@
 def _update_anthropic_message_with_tool_call_results(
     tool_call_results: list[ToolCallResult],
     content: list[
-        Union[
-            TextBlockParam,
-            ToolUseBlockParam,
-            ToolResultBlockParam,
-            ImageBlockParam,
-            ThinkingBlockParam,
-            RedactedThinkingBlockParam,
-        ]
+        TextBlockParam
+        | ToolUseBlockParam
+        | ToolResultBlockParam
+        | ImageBlockParam
+        | ThinkingBlockParam
+        | RedactedThinkingBlockParam
     ],
 ) -> None:
     """
@@ -130,14 +128,12 @@ def _convert_messages_to_anthropic_format(
             continue
 
         content: list[
-            Union[
-                TextBlockParam,
-                ToolUseBlockParam,
-                ToolResultBlockParam,
-                ImageBlockParam,
-                ThinkingBlockParam,
-                RedactedThinkingBlockParam,
-            ]
+            TextBlockParam
+            | ToolUseBlockParam
+            | ToolResultBlockParam
+            | ImageBlockParam
+            | ThinkingBlockParam
+            | RedactedThinkingBlockParam
         ] = []
 
         # Handle multimodal content (text and images) preserving order
@@ -222,7 +218,7 @@ def _convert_messages_to_anthropic_format(
 
         # Anthropic only supports assistant and user roles in messages. User role is also used for tool messages.
         # System messages are passed separately.
-        role: Union[Literal["assistant"], Literal["user"]] = "user"
+        role: Literal["assistant"] | Literal["user"] = "user"
         if message._role == ChatRole.ASSISTANT:
             role = "assistant"
 
@@ -358,7 +354,7 @@ def _convert_anthropic_chunk_to_streaming_chunk(
     )
 
 
-def _process_reasoning_contents(chunks: list[StreamingChunk]) -> Optional[ReasoningContent]:
+def _process_reasoning_contents(chunks: list[StreamingChunk]) -> ReasoningContent | None:
     """
     Process reasoning contents from a list of StreamingChunk objects into the Anthropic expected format.
 

integrations/anthropic/src/haystack_integrations/components/generators/anthropic/chat/vertex_chat_generator.py

@@ -1,5 +1,6 @@
 import os
-from typing import Any, Callable, Optional
+from collections.abc import Callable
+from typing import Any
 
 from haystack import component, default_from_dict, default_to_dict, logging
 from haystack.dataclasses import StreamingChunk
@@ -70,13 +71,13 @@ def __init__(
         region: str,
         project_id: str,
         model: str = "claude-sonnet-4@20250514",
-        streaming_callback: Optional[Callable[[StreamingChunk], None]] = None,
-        generation_kwargs: Optional[dict[str, Any]] = None,
+        streaming_callback: Callable[[StreamingChunk], None] | None = None,
+        generation_kwargs: dict[str, Any] | None = None,
         ignore_tools_thinking_messages: bool = True,
-        tools: Optional[ToolsType] = None,
+        tools: ToolsType | None = None,
         *,
-        timeout: Optional[float] = None,
-        max_retries: Optional[int] = None,
+        timeout: float | None = None,
+        max_retries: int | None = None,
     ):
         """
         Creates an instance of AnthropicVertexChatGenerator.

integrations/anthropic/src/haystack_integrations/components/generators/anthropic/generator.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, ClassVar, Optional, Union
+from collections.abc import Callable
+from typing import Any, ClassVar
 
 from haystack import component, default_from_dict, default_to_dict, logging
 from haystack.dataclasses import StreamingChunk
@@ -61,12 +62,12 @@ def __init__(
         self,
         api_key: Secret = Secret.from_env_var("ANTHROPIC_API_KEY"),  # noqa: B008
         model: str = "claude-sonnet-4-20250514",
-        streaming_callback: Optional[Callable[[StreamingChunk], None]] = None,
-        system_prompt: Optional[str] = None,
-        generation_kwargs: Optional[dict[str, Any]] = None,
+        streaming_callback: Callable[[StreamingChunk], None] | None = None,
+        system_prompt: str | None = None,
+        generation_kwargs: dict[str, Any] | None = None,
         *,
-        timeout: Optional[float] = None,
-        max_retries: Optional[int] = None,
+        timeout: float | None = None,
+        max_retries: int | None = None,
     ):
         """
         Initialize the AnthropicGenerator.
@@ -147,9 +148,9 @@ def from_dict(cls, data: dict[str, Any]) -> "AnthropicGenerator":
     def run(
         self,
         prompt: str,
-        generation_kwargs: Optional[dict[str, Any]] = None,
-        streaming_callback: Optional[Callable[[StreamingChunk], None]] = None,
-    ) -> dict[str, Union[list[str], list[dict[str, Any]]]]:
+        generation_kwargs: dict[str, Any] | None = None,
+        streaming_callback: Callable[[StreamingChunk], None] | None = None,
+    ) -> dict[str, list[str] | list[dict[str, Any]]]:
         """
         Generate replies using the Anthropic API.
 
@@ -174,7 +175,7 @@ def run(
 
         streaming_callback = streaming_callback or self.streaming_callback
         stream = streaming_callback is not None
-        response: Union[Message, Stream[MessageStreamEvent]] = self.client.messages.create(
+        response: Message | Stream[MessageStreamEvent] = self.client.messages.create(
             max_tokens=filtered_generation_kwargs.pop("max_tokens", 512),
             system=self.system_prompt if self.system_prompt else filtered_generation_kwargs.pop("system", ""),
             model=self.model,
@@ -244,7 +245,7 @@ def run(
             if self.include_thinking and len(thinkings) == len(completions):
                 completions = [
                     f"{self.thinking_tag_start}{thinking}{self.thinking_tag_end}{completion}"
-                    for thinking, completion in zip(thinkings, completions)
+                    for thinking, completion in zip(thinkings, completions, strict=True)
                 ]
 
             meta.update(