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

Author: anakin87

integrations/opensearch/pyproject.toml

@@ -7,15 +7,14 @@ name = "opensearch-haystack"
 dynamic = ["version"]
 description = 'Haystack 2.x Document Store for OpenSearch'
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = "Apache-2.0"
 keywords = []
 authors = [{ name = "deepset", 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",
@@ -24,7 +23,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dependencies = [
-  "haystack-ai>=2.14.0",
+  "haystack-ai>=2.22.0",
   "opensearch-py[async]>=2.4.0,<3"]
 
 [project.urls]
@@ -85,7 +84,6 @@ allow-direct-references = true
 
 
 [tool.ruff]
-target-version = "py39"
 line-length = 120
 
 [tool.ruff.lint]
@@ -134,10 +132,6 @@ ignore = [
   # Ignore asserts
   "S101",
 ]
-unfixable = [
-  # Don't touch unused imports
-  "F401",
-]
 
 [tool.ruff.lint.isort]
 known-first-party = ["haystack_integrations"]

integrations/opensearch/src/haystack_integrations/components/retrievers/opensearch/bm25_retriever.py

@@ -4,7 +4,7 @@
 
 # ruff: noqa: FBT001  Boolean-typed positional argument in function definition
 
-from typing import Any, Optional, Union
+from typing import Any
 
 from haystack import component, default_from_dict, default_to_dict, logging
 from haystack.dataclasses import Document
@@ -28,13 +28,13 @@ def __init__(
         self,
         *,
         document_store: OpenSearchDocumentStore,
-        filters: Optional[dict[str, Any]] = None,
-        fuzziness: Union[int, str] = "AUTO",
+        filters: dict[str, Any] | None = None,
+        fuzziness: int | str = "AUTO",
         top_k: int = 10,
         scale_score: bool = False,
         all_terms_must_match: bool = False,
-        filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
-        custom_query: Optional[dict[str, Any]] = None,
+        filter_policy: str | FilterPolicy = FilterPolicy.REPLACE,
+        custom_query: dict[str, Any] | None = None,
         raise_on_failure: bool = True,
     ):
         """
@@ -158,12 +158,12 @@ def _prepare_bm25_args(
         self,
         *,
         query: str,
-        filters: Optional[dict[str, Any]],
-        all_terms_must_match: Optional[bool],
-        top_k: Optional[int],
-        fuzziness: Optional[Union[str, int]],
-        scale_score: Optional[bool],
-        custom_query: Optional[dict[str, Any]],
+        filters: dict[str, Any] | None,
+        all_terms_must_match: bool | None,
+        top_k: int | None,
+        fuzziness: str | int | None,
+        scale_score: bool | None,
+        custom_query: dict[str, Any] | None,
     ) -> dict[str, Any]:
         filters = apply_filter_policy(self._filter_policy, self._filters, filters)
 
@@ -194,13 +194,13 @@ def _prepare_bm25_args(
     def run(
         self,
         query: str,
-        filters: Optional[dict[str, Any]] = None,
-        all_terms_must_match: Optional[bool] = None,
-        top_k: Optional[int] = None,
-        fuzziness: Optional[Union[int, str]] = None,
-        scale_score: Optional[bool] = None,
-        custom_query: Optional[dict[str, Any]] = None,
-        document_store: Optional[OpenSearchDocumentStore] = None,
+        filters: dict[str, Any] | None = None,
+        all_terms_must_match: bool | None = None,
+        top_k: int | None = None,
+        fuzziness: int | str | None = None,
+        scale_score: bool | None = None,
+        custom_query: dict[str, Any] | None = None,
+        document_store: OpenSearchDocumentStore | None = None,
     ) -> dict[str, list[Document]]:
         """
         Retrieve documents using BM25 retrieval.
@@ -294,13 +294,13 @@ def run(
     async def run_async(  # pylint: disable=too-many-positional-arguments
         self,
         query: str,
-        filters: Optional[dict[str, Any]] = None,
-        all_terms_must_match: Optional[bool] = None,
-        top_k: Optional[int] = None,
-        fuzziness: Optional[Union[int, str]] = None,
-        scale_score: Optional[bool] = None,
-        custom_query: Optional[dict[str, Any]] = None,
-        document_store: Optional[OpenSearchDocumentStore] = None,
+        filters: dict[str, Any] | None = None,
+        all_terms_must_match: bool | None = None,
+        top_k: int | None = None,
+        fuzziness: int | str | None = None,
+        scale_score: bool | None = None,
+        custom_query: dict[str, Any] | None = None,
+        document_store: OpenSearchDocumentStore | None = None,
     ) -> dict[str, list[Document]]:
         """
         Asynchronously retrieve documents using BM25 retrieval.

integrations/opensearch/src/haystack_integrations/components/retrievers/opensearch/embedding_retriever.py

@@ -4,7 +4,7 @@
 
 # ruff: noqa: FBT001  Boolean-typed positional argument in function definition
 
-from typing import Any, Optional, Union
+from typing import Any
 
 from haystack import component, default_from_dict, default_to_dict, logging
 from haystack.dataclasses import Document
@@ -28,10 +28,10 @@ def __init__(
         self,
         *,
         document_store: OpenSearchDocumentStore,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
         top_k: int = 10,
-        filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
-        custom_query: Optional[dict[str, Any]] = None,
+        filter_policy: str | FilterPolicy = FilterPolicy.REPLACE,
+        custom_query: dict[str, Any] | None = None,
         raise_on_failure: bool = True,
         efficient_filtering: bool = False,
     ):
@@ -150,11 +150,11 @@ def from_dict(cls, data: dict[str, Any]) -> "OpenSearchEmbeddingRetriever":
     def run(
         self,
         query_embedding: list[float],
-        filters: Optional[dict[str, Any]] = None,
-        top_k: Optional[int] = None,
-        custom_query: Optional[dict[str, Any]] = None,
-        efficient_filtering: Optional[bool] = None,
-        document_store: Optional[OpenSearchDocumentStore] = None,
+        filters: dict[str, Any] | None = None,
+        top_k: int | None = None,
+        custom_query: dict[str, Any] | None = None,
+        efficient_filtering: bool | None = None,
+        document_store: OpenSearchDocumentStore | None = None,
     ) -> dict[str, list[Document]]:
         """
         Retrieve documents using a vector similarity metric.
@@ -259,11 +259,11 @@ def run(
     async def run_async(
         self,
         query_embedding: list[float],
-        filters: Optional[dict[str, Any]] = None,
-        top_k: Optional[int] = None,
-        custom_query: Optional[dict[str, Any]] = None,
-        efficient_filtering: Optional[bool] = None,
-        document_store: Optional[OpenSearchDocumentStore] = None,
+        filters: dict[str, Any] | None = None,
+        top_k: int | None = None,
+        custom_query: dict[str, Any] | None = None,
+        efficient_filtering: bool | None = None,
+        document_store: OpenSearchDocumentStore | None = None,
     ) -> dict[str, list[Document]]:
         """
         Asynchronously retrieve documents using a vector similarity metric.

integrations/opensearch/src/haystack_integrations/components/retrievers/opensearch/open_search_hybrid_retriever.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from haystack import Document, Pipeline, default_from_dict, default_to_dict, logging, super_component
 from haystack.components.embedders.types import TextEmbedder
@@ -92,22 +92,22 @@ def __init__(
         *,
         embedder: TextEmbedder,
         # OpenSearchBM25Retriever
-        filters_bm25: Optional[dict[str, Any]] = None,
-        fuzziness: Union[int, str] = "AUTO",
+        filters_bm25: dict[str, Any] | None = None,
+        fuzziness: int | str = "AUTO",
         top_k_bm25: int = 10,
         scale_score: bool = False,
         all_terms_must_match: bool = False,
-        filter_policy_bm25: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
-        custom_query_bm25: Optional[dict[str, Any]] = None,
+        filter_policy_bm25: str | FilterPolicy = FilterPolicy.REPLACE,
+        custom_query_bm25: dict[str, Any] | None = None,
         # OpenSearchEmbeddingRetriever
-        filters_embedding: Optional[dict[str, Any]] = None,
+        filters_embedding: dict[str, Any] | None = None,
         top_k_embedding: int = 10,
-        filter_policy_embedding: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
-        custom_query_embedding: Optional[dict[str, Any]] = None,
+        filter_policy_embedding: str | FilterPolicy = FilterPolicy.REPLACE,
+        custom_query_embedding: dict[str, Any] | None = None,
         # DocumentJoiner
-        join_mode: Union[str, JoinMode] = JoinMode.RECIPROCAL_RANK_FUSION,
-        weights: Optional[list[float]] = None,
-        top_k: Optional[int] = None,
+        join_mode: str | JoinMode = JoinMode.RECIPROCAL_RANK_FUSION,
+        weights: list[float] | None = None,
+        top_k: int | None = None,
         sort_by_score: bool = True,
         # extra kwargs
         **kwargs: Any,
@@ -242,10 +242,10 @@ def warm_up(self) -> None: ...
         def run(
             self,
             query: str,
-            filters_bm25: Optional[dict[str, Any]] = None,
-            filters_embedding: Optional[dict[str, Any]] = None,
-            top_k_bm25: Optional[int] = None,
-            top_k_embedding: Optional[int] = None,
+            filters_bm25: dict[str, Any] | None = None,
+            filters_embedding: dict[str, Any] | None = None,
+            top_k_bm25: int | None = None,
+            top_k_embedding: int | None = None,
         ) -> dict[str, list[Document]]: ...
 
     def _create_pipeline(self, data: dict[str, Any]) -> Pipeline:

integrations/opensearch/src/haystack_integrations/document_stores/opensearch/auth.py

@@ -27,16 +27,16 @@ class AWSConfigurationError(DocumentStoreError):
     """Exception raised when AWS is not configured correctly"""
 
 
-def _resolve_secret(secret: Optional[Secret]) -> Optional[str]:
+def _resolve_secret(secret: Secret | None) -> str | None:
     return secret.resolve_value() if secret else None
 
 
 def _get_aws_session(
-    aws_access_key_id: Optional[str] = None,
-    aws_secret_access_key: Optional[str] = None,
-    aws_session_token: Optional[str] = None,
-    aws_region_name: Optional[str] = None,
-    aws_profile_name: Optional[str] = None,
+    aws_access_key_id: str | None = None,
+    aws_secret_access_key: str | None = None,
+    aws_session_token: str | None = None,
+    aws_region_name: str | None = None,
+    aws_profile_name: str | None = None,
     **kwargs: Any,
 ) -> "boto3.Session":
     """
@@ -78,19 +78,19 @@ class AWSAuth:
     the necessary `Urllib3AWSV4SignerAuth` creation steps including boto3 Sessions and boto3 credentials.
     """
 
-    aws_access_key_id: Optional[Secret] = field(
+    aws_access_key_id: Secret | None = field(
         default_factory=lambda: Secret.from_env_var("AWS_ACCESS_KEY_ID", strict=False)
     )
-    aws_secret_access_key: Optional[Secret] = field(
+    aws_secret_access_key: Secret | None = field(
         default_factory=lambda: Secret.from_env_var("AWS_SECRET_ACCESS_KEY", strict=False)
     )
-    aws_session_token: Optional[Secret] = field(
+    aws_session_token: Secret | None = field(
         default_factory=lambda: Secret.from_env_var("AWS_SESSION_TOKEN", strict=False)
     )
-    aws_region_name: Optional[Secret] = field(
+    aws_region_name: Secret | None = field(
         default_factory=lambda: Secret.from_env_var("AWS_DEFAULT_REGION", strict=False)
     )
-    aws_profile_name: Optional[Secret] = field(default_factory=lambda: Secret.from_env_var("AWS_PROFILE", strict=False))
+    aws_profile_name: Secret | None = field(default_factory=lambda: Secret.from_env_var("AWS_PROFILE", strict=False))
     aws_service: str = field(default="es")
 
     def __post_init__(self) -> None:
@@ -106,7 +106,7 @@ def to_dict(self) -> dict[str, Any]:
         _fields = {}
         for _field in fields(self):
             field_value = getattr(self, _field.name)
-            if _field.type == Optional[Secret]:
+            if _field.type == Secret | None:
                 _fields[_field.name] = field_value.to_dict() if field_value is not None else None
             else:
                 _fields[_field.name] = field_value