pgvector-haystack 5.3.0__tar.gz → 5.4.0__tar.gz

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [integrations/pgvector-v5.3.0] - 2025-10-17
+
+### 🚀 Features
+
+- `PgvectorDocumentStore` now supports `delete_all_documents` and  `delete_all_documents_async` (#2394)
+
+### 🧹 Chores
+
+- Standardize readmes - part 2 (#2205)
+
+
 ## [integrations/pgvector-v5.2.1] - 2025-07-03
 
 ### 🐛 Bug Fixes

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgvector-haystack
-Version: 5.3.0
+Version: 5.4.0
 Summary: An integration of pgvector (vector search extension for Postgres) with Haystack
 Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/pgvector/README.md

pgvector_haystack-5.4.0/pydoc/config_docusaurus.yml

@@ -0,0 +1,30 @@
+loaders:
+- ignore_when_discovered:
+  - __init__
+  modules:
+  - haystack_integrations.components.retrievers.pgvector.embedding_retriever
+  - haystack_integrations.components.retrievers.pgvector.keyword_retriever
+  - haystack_integrations.document_stores.pgvector.document_store
+  search_path:
+  - ../src
+  type: haystack_pydoc_tools.loaders.CustomPythonLoader
+processors:
+- do_not_filter_modules: false
+  documented_only: true
+  expression: null
+  skip_empty_modules: true
+  type: filter
+- type: smart
+- type: crossref
+renderer:
+  description: Pgvector integration for Haystack
+  id: integrations-pgvector
+  markdown:
+    add_member_class_prefix: false
+    add_method_class_prefix: true
+    classdef_code_block: false
+    descriptive_class_title: false
+    descriptive_module_title: true
+    filename: pgvector.md
+  title: Pgvector
+  type: haystack_pydoc_tools.renderers.DocusaurusRenderer

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/pyproject.toml

@@ -46,7 +46,7 @@ installer = "uv"
 dependencies = ["haystack-pydoc-tools", "ruff"]
 
 [tool.hatch.envs.default.scripts]
-docs = ["pydoc-markdown pydoc/config.yml"]
+docs = ["pydoc-markdown pydoc/config_docusaurus.yml"]
 fmt = "ruff check --fix {args} && ruff format {args}"
 fmt-check = "ruff check {args} && ruff format --check {args}"
 
@@ -64,7 +64,7 @@ dependencies = [
 unit = 'pytest -m "not integration" {args:tests}'
 integration = 'pytest -m "integration" {args:tests}'
 all = 'pytest {args:tests}'
-cov-retry = 'all --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x'
+cov-retry = 'pytest --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x {args:tests}'
 
 types = "mypy -p haystack_integrations.document_stores.pgvector -p haystack_integrations.components.retrievers.pgvector {args}"
 
@@ -83,7 +83,7 @@ ignore_missing_imports = true
 
 
 [tool.ruff]
-target-version = "py38"
+target-version = "py39"
 line-length = 120
 
 [tool.ruff.lint]

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/src/haystack_integrations/components/retrievers/pgvector/embedding_retriever.py

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
 #
 # SPDX-License-Identifier: Apache-2.0
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Any, Literal, Optional, Union
 
 from haystack import component, default_from_dict, default_to_dict
 from haystack.dataclasses import Document
@@ -62,7 +62,7 @@ class PgvectorEmbeddingRetriever:
         self,
         *,
         document_store: PgvectorDocumentStore,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: int = 10,
         vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
         filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
@@ -99,7 +99,7 @@ class PgvectorEmbeddingRetriever:
             filter_policy if isinstance(filter_policy, FilterPolicy) else FilterPolicy.from_str(filter_policy)
         )
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """
         Serializes the component to a dictionary.
 
@@ -116,7 +116,7 @@ class PgvectorEmbeddingRetriever:
         )
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "PgvectorEmbeddingRetriever":
+    def from_dict(cls, data: dict[str, Any]) -> "PgvectorEmbeddingRetriever":
         """
         Deserializes the component from a dictionary.
 
@@ -133,14 +133,14 @@ class PgvectorEmbeddingRetriever:
             data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(filter_policy)
         return default_from_dict(cls, data)
 
-    @component.output_types(documents=List[Document])
+    @component.output_types(documents=list[Document])
     def run(
         self,
-        query_embedding: List[float],
-        filters: Optional[Dict[str, Any]] = None,
+        query_embedding: list[float],
+        filters: Optional[dict[str, Any]] = None,
         top_k: Optional[int] = None,
         vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
-    ) -> Dict[str, List[Document]]:
+    ) -> dict[str, list[Document]]:
         """
         Retrieve documents from the `PgvectorDocumentStore`, based on their embeddings.
 
@@ -166,14 +166,14 @@ class PgvectorEmbeddingRetriever:
         )
         return {"documents": docs}
 
-    @component.output_types(documents=List[Document])
+    @component.output_types(documents=list[Document])
     async def run_async(
         self,
-        query_embedding: List[float],
-        filters: Optional[Dict[str, Any]] = None,
+        query_embedding: list[float],
+        filters: Optional[dict[str, Any]] = None,
         top_k: Optional[int] = None,
         vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
-    ) -> Dict[str, List[Document]]:
+    ) -> dict[str, list[Document]]:
         """
         Asynchronously retrieve documents from the `PgvectorDocumentStore`, based on their embeddings.
 

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/src/haystack_integrations/components/retrievers/pgvector/keyword_retriever.py

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
 #
 # SPDX-License-Identifier: Apache-2.0
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 
 from haystack import component, default_from_dict, default_to_dict
 from haystack.dataclasses import Document
@@ -52,7 +52,7 @@ class PgvectorKeywordRetriever:
         self,
         *,
         document_store: PgvectorDocumentStore,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: int = 10,
         filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
     ):
@@ -74,7 +74,7 @@ class PgvectorKeywordRetriever:
             filter_policy if isinstance(filter_policy, FilterPolicy) else FilterPolicy.from_str(filter_policy)
         )
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """
         Serializes the component to a dictionary.
 
@@ -90,7 +90,7 @@ class PgvectorKeywordRetriever:
         )
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "PgvectorKeywordRetriever":
+    def from_dict(cls, data: dict[str, Any]) -> "PgvectorKeywordRetriever":
         """
         Deserializes the component from a dictionary.
 
@@ -107,13 +107,13 @@ class PgvectorKeywordRetriever:
             data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(filter_policy)
         return default_from_dict(cls, data)
 
-    @component.output_types(documents=List[Document])
+    @component.output_types(documents=list[Document])
     def run(
         self,
         query: str,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: Optional[int] = None,
-    ) -> Dict[str, List[Document]]:
+    ) -> dict[str, list[Document]]:
         """
         Retrieve documents from the `PgvectorDocumentStore`, based on keywords.
 
@@ -137,13 +137,13 @@ class PgvectorKeywordRetriever:
         )
         return {"documents": docs}
 
-    @component.output_types(documents=List[Document])
+    @component.output_types(documents=list[Document])
     async def run_async(
         self,
         query: str,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: Optional[int] = None,
-    ) -> Dict[str, List[Document]]:
+    ) -> dict[str, list[Document]]:
         """
         Asynchronously retrieve documents from the `PgvectorDocumentStore`, based on keywords.
 

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/src/haystack_integrations/document_stores/pgvector/converters.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any
 
 from haystack import logging
 from haystack.dataclasses import ByteStream, Document
@@ -7,7 +7,7 @@ from psycopg.types.json import Jsonb
 logger = logging.getLogger(__name__)
 
 
-def _from_haystack_to_pg_documents(documents: List[Document]) -> List[Dict[str, Any]]:
+def _from_haystack_to_pg_documents(documents: list[Document]) -> list[dict[str, Any]]:
     """
     Internal method to convert a list of Haystack Documents to a list of dictionaries that can be used to insert
     documents into the PgvectorDocumentStore.
@@ -38,7 +38,7 @@ def _from_haystack_to_pg_documents(documents: List[Document]) -> List[Dict[str,
     return db_documents
 
 
-def _from_pg_to_haystack_documents(documents: List[Dict[str, Any]]) -> List[Document]:
+def _from_pg_to_haystack_documents(documents: list[dict[str, Any]]) -> list[Document]:
     """
     Internal method to convert a list of dictionaries from pgvector to a list of Haystack Documents.
     """

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/src/haystack_integrations/document_stores/pgvector/document_store.py

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
 #
 # SPDX-License-Identifier: Apache-2.0
-from typing import Any, Dict, List, Literal, Optional, Tuple, Union, overload
+from typing import Any, Literal, Optional, Union, overload
 
 from haystack import default_from_dict, default_to_dict, logging
 from haystack.dataclasses.document import Document
@@ -90,7 +90,7 @@ class PgvectorDocumentStore:
         recreate_table: bool = False,
         search_strategy: Literal["exact_nearest_neighbor", "hnsw"] = "exact_nearest_neighbor",
         hnsw_recreate_index_if_exists: bool = False,
-        hnsw_index_creation_kwargs: Optional[Dict[str, int]] = None,
+        hnsw_index_creation_kwargs: Optional[dict[str, int]] = None,
         hnsw_index_name: str = "haystack_hnsw_index",
         hnsw_ef_search: Optional[int] = None,
         keyword_index_name: str = "haystack_keyword_index",
@@ -101,9 +101,10 @@ class PgvectorDocumentStore:
         A specific table to store Haystack documents will be created if it doesn't exist yet.
 
         :param connection_string: The connection string to use to connect to the PostgreSQL database, defined as an
-            environment variable. It can be provided in either URI format
-            e.g.: `PG_CONN_STR="postgresql://USER:PASSWORD@HOST:PORT/DB_NAME"`, or keyword/value format
-            e.g.: `PG_CONN_STR="host=HOST port=PORT dbname=DBNAME user=USER password=PASSWORD"`
+            environment variable. Supported formats:
+            - URI, e.g. `PG_CONN_STR="postgresql://USER:PASSWORD@HOST:PORT/DB_NAME"` (use percent-encoding for special
+                characters)
+            - keyword/value format, e.g. `PG_CONN_STR="host=HOST port=PORT dbname=DBNAME user=USER password=PASSWORD"`
             See [PostgreSQL Documentation](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING)
             for more details.
         :param create_extension: Whether to create the pgvector extension if it doesn't exist.
@@ -180,7 +181,7 @@ class PgvectorDocumentStore:
         self._async_dict_cursor: Optional[AsyncCursor[DictRow]] = None
         self._table_initialized = False
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """
         Serializes the component to a dictionary.
 
@@ -207,7 +208,7 @@ class PgvectorDocumentStore:
         )
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "PgvectorDocumentStore":
+    def from_dict(cls, data: dict[str, Any]) -> "PgvectorDocumentStore":
         """
         Deserializes the component from a dictionary.
 
@@ -360,7 +361,15 @@ class PgvectorDocumentStore:
                 logger.debug("Failed to close connection: {e}", e=str(e))
 
         conn_str = self.connection_string.resolve_value() or ""
-        connection = Connection.connect(conn_str)
+        try:
+            connection = Connection.connect(conn_str)
+        except Error as e:
+            msg = (
+                "Failed to connect to PostgreSQL database.  Ensure the connection string follows the "
+                "PostgreSQL connection specification: "
+                "https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING."
+            )
+            raise DocumentStoreError(msg) from e
         connection.autocommit = True
         if self.create_extension:
             connection.execute("CREATE EXTENSION IF NOT EXISTS vector")
@@ -394,7 +403,15 @@ class PgvectorDocumentStore:
             await self._async_connection.close()
 
         conn_str = self.connection_string.resolve_value() or ""
-        async_connection = await AsyncConnection.connect(conn_str)
+        try:
+            async_connection = await AsyncConnection.connect(conn_str)
+        except Error as e:
+            msg = (
+                "Failed to connect to PostgreSQL database.  Ensure the connection string follows the "
+                "PostgreSQL connection specification: "
+                "https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING."
+            )
+            raise DocumentStoreError(msg) from e
         await async_connection.set_autocommit(True)
         if self.create_extension:
             await async_connection.execute("CREATE EXTENSION IF NOT EXISTS vector")
@@ -740,7 +757,7 @@ class PgvectorDocumentStore:
             return result[0]
         return 0
 
-    def filter_documents(self, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+    def filter_documents(self, filters: Optional[dict[str, Any]] = None) -> list[Document]:
         """
         Returns the documents that match the filters provided.
 
@@ -777,7 +794,7 @@ class PgvectorDocumentStore:
         docs = _from_pg_to_haystack_documents(records)
         return docs
 
-    async def filter_documents_async(self, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+    async def filter_documents_async(self, filters: Optional[dict[str, Any]] = None) -> list[Document]:
         """
         Asynchronously returns the documents that match the filters provided.
 
@@ -832,7 +849,7 @@ class PgvectorDocumentStore:
 
         return sql_insert
 
-    def write_documents(self, documents: List[Document], policy: DuplicatePolicy = DuplicatePolicy.NONE) -> int:
+    def write_documents(self, documents: list[Document], policy: DuplicatePolicy = DuplicatePolicy.NONE) -> int:
         """
         Writes documents to the document store.
 
@@ -888,7 +905,7 @@ class PgvectorDocumentStore:
         return written_docs
 
     async def write_documents_async(
-        self, documents: List[Document], policy: DuplicatePolicy = DuplicatePolicy.NONE
+        self, documents: list[Document], policy: DuplicatePolicy = DuplicatePolicy.NONE
     ) -> int:
         """
         Asynchronously writes documents to the document store.
@@ -939,7 +956,7 @@ class PgvectorDocumentStore:
 
         return written_docs
 
-    def delete_documents(self, document_ids: List[str]) -> None:
+    def delete_documents(self, document_ids: list[str]) -> None:
         """
         Deletes documents that match the provided `document_ids` from the document store.
 
@@ -962,7 +979,7 @@ class PgvectorDocumentStore:
             cursor=self._cursor, sql_query=delete_sql, error_msg="Could not delete documents from PgvectorDocumentStore"
         )
 
-    async def delete_documents_async(self, document_ids: List[str]) -> None:
+    async def delete_documents_async(self, document_ids: list[str]) -> None:
         """
         Asynchronously deletes documents that match the provided `document_ids` from the document store.
 
@@ -1020,8 +1037,8 @@ class PgvectorDocumentStore:
         )
 
     def _build_keyword_retrieval_query(
-        self, query: str, top_k: int, filters: Optional[Dict[str, Any]] = None
-    ) -> Tuple[Composed, tuple]:
+        self, query: str, top_k: int, filters: Optional[dict[str, Any]] = None
+    ) -> tuple[Composed, tuple]:
         """
         Builds the SQL query and the where parameters for keyword retrieval.
         """
@@ -1049,9 +1066,9 @@ class PgvectorDocumentStore:
         self,
         query: str,
         *,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: int = 10,
-    ) -> List[Document]:
+    ) -> list[Document]:
         """
         Retrieves documents that are most similar to the query using a full-text search.
 
@@ -1084,9 +1101,9 @@ class PgvectorDocumentStore:
         self,
         query: str,
         *,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: int = 10,
-    ) -> List[Document]:
+    ) -> list[Document]:
         """
         Retrieves documents that are most similar to the query using a full-text search asynchronously.
         """
@@ -1111,11 +1128,11 @@ class PgvectorDocumentStore:
 
     def _check_and_build_embedding_retrieval_query(
         self,
-        query_embedding: List[float],
+        query_embedding: list[float],
         vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]],
         top_k: int,
-        filters: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[Composed, tuple]:
+        filters: Optional[dict[str, Any]] = None,
+    ) -> tuple[Composed, tuple]:
         """
         Performs checks and builds the SQL query and the where parameters for embedding retrieval.
         """
@@ -1174,12 +1191,12 @@ class PgvectorDocumentStore:
 
     def _embedding_retrieval(
         self,
-        query_embedding: List[float],
+        query_embedding: list[float],
         *,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: int = 10,
         vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
-    ) -> List[Document]:
+    ) -> list[Document]:
         """
         Retrieves documents that are most similar to the query embedding using a vector similarity metric.
 
@@ -1208,12 +1225,12 @@ class PgvectorDocumentStore:
 
     async def _embedding_retrieval_async(
         self,
-        query_embedding: List[float],
+        query_embedding: list[float],
         *,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: int = 10,
         vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
-    ) -> List[Document]:
+    ) -> list[Document]:
         """
         Asynchronously retrieves documents that are most similar to the query embedding using a
         vector similarity metric.

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/src/haystack_integrations/document_stores/pgvector/filters.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 from datetime import datetime
 from itertools import chain
-from typing import Any, Dict, List, Literal, Optional, Tuple
+from typing import Any, Literal, Optional
 
 from haystack.errors import FilterError
 from psycopg.sql import SQL, Composed
@@ -21,7 +21,7 @@ PYTHON_TYPES_TO_PG_TYPES = {
 NO_VALUE = "no_value"
 
 
-def _validate_filters(filters: Optional[Dict[str, Any]] = None) -> None:
+def _validate_filters(filters: Optional[dict[str, Any]] = None) -> None:
     """
     Validates the filters provided.
     """
@@ -35,8 +35,8 @@ def _validate_filters(filters: Optional[Dict[str, Any]] = None) -> None:
 
 
 def _convert_filters_to_where_clause_and_params(
-    filters: Dict[str, Any], operator: Literal["WHERE", "AND"] = "WHERE"
-) -> Tuple[Composed, Tuple]:
+    filters: dict[str, Any], operator: Literal["WHERE", "AND"] = "WHERE"
+) -> tuple[Composed, tuple]:
     """
     Convert Haystack filters to a WHERE clause and a tuple of params to query PostgreSQL.
     """
@@ -51,7 +51,7 @@ def _convert_filters_to_where_clause_and_params(
     return where_clause, params
 
 
-def _parse_logical_condition(condition: Dict[str, Any]) -> Tuple[str, List[Any]]:
+def _parse_logical_condition(condition: dict[str, Any]) -> tuple[str, list[Any]]:
     if "operator" not in condition:
         msg = f"'operator' key missing in {condition}"
         raise FilterError(msg)
@@ -91,7 +91,7 @@ def _parse_logical_condition(condition: Dict[str, Any]) -> Tuple[str, List[Any]]
     return sql_query, values
 
 
-def _parse_comparison_condition(condition: Dict[str, Any]) -> Tuple[str, List[Any]]:
+def _parse_comparison_condition(condition: dict[str, Any]) -> tuple[str, list[Any]]:
     field: str = condition["field"]
     if "operator" not in condition:
         msg = f"'operator' key missing in {condition}"
@@ -142,20 +142,20 @@ def _treat_meta_field(field: str, value: Any) -> str:
     return field
 
 
-def _equal(field: str, value: Any) -> Tuple[str, Any]:
+def _equal(field: str, value: Any) -> tuple[str, Any]:
     if value is None:
         # NO_VALUE is a placeholder that will be removed in _convert_filters_to_where_clause_and_params
         return f"{field} IS NULL", NO_VALUE
     return f"{field} = %s", value
 
 
-def _not_equal(field: str, value: Any) -> Tuple[str, Any]:
+def _not_equal(field: str, value: Any) -> tuple[str, Any]:
     # we use IS DISTINCT FROM to correctly handle NULL values
     # (not handled by !=)
     return f"{field} IS DISTINCT FROM %s", value
 
 
-def _greater_than(field: str, value: Any) -> Tuple[str, Any]:
+def _greater_than(field: str, value: Any) -> tuple[str, Any]:
     if isinstance(value, str):
         try:
             datetime.fromisoformat(value)
@@ -172,7 +172,7 @@ def _greater_than(field: str, value: Any) -> Tuple[str, Any]:
     return f"{field} > %s", value
 
 
-def _greater_than_equal(field: str, value: Any) -> Tuple[str, Any]:
+def _greater_than_equal(field: str, value: Any) -> tuple[str, Any]:
     if isinstance(value, str):
         try:
             datetime.fromisoformat(value)
@@ -189,7 +189,7 @@ def _greater_than_equal(field: str, value: Any) -> Tuple[str, Any]:
     return f"{field} >= %s", value
 
 
-def _less_than(field: str, value: Any) -> Tuple[str, Any]:
+def _less_than(field: str, value: Any) -> tuple[str, Any]:
     if isinstance(value, str):
         try:
             datetime.fromisoformat(value)
@@ -206,7 +206,7 @@ def _less_than(field: str, value: Any) -> Tuple[str, Any]:
     return f"{field} < %s", value
 
 
-def _less_than_equal(field: str, value: Any) -> Tuple[str, Any]:
+def _less_than_equal(field: str, value: Any) -> tuple[str, Any]:
     if isinstance(value, str):
         try:
             datetime.fromisoformat(value)
@@ -223,7 +223,7 @@ def _less_than_equal(field: str, value: Any) -> Tuple[str, Any]:
     return f"{field} <= %s", value
 
 
-def _not_in(field: str, value: Any) -> Tuple[str, List]:
+def _not_in(field: str, value: Any) -> tuple[str, list]:
     if not isinstance(value, list):
         msg = f"{field}'s value must be a list when using 'not in' comparator in Pinecone"
         raise FilterError(msg)
@@ -231,7 +231,7 @@ def _not_in(field: str, value: Any) -> Tuple[str, List]:
     return f"{field} IS NULL OR {field} != ALL(%s)", [value]
 
 
-def _in(field: str, value: Any) -> Tuple[str, List]:
+def _in(field: str, value: Any) -> tuple[str, list]:
     if not isinstance(value, list):
         msg = f"{field}'s value must be a list when using 'in' comparator in Pinecone"
         raise FilterError(msg)
@@ -240,14 +240,14 @@ def _in(field: str, value: Any) -> Tuple[str, List]:
     return f"{field} = ANY(%s)", [value]
 
 
-def _like(field: str, value: Any) -> Tuple[str, Any]:
+def _like(field: str, value: Any) -> tuple[str, Any]:
     if not isinstance(value, str):
         msg = f"{field}'s value must be a str when using 'LIKE' "
         raise FilterError(msg)
     return f"{field} LIKE %s", value
 
 
-def _not_like(field: str, value: Any) -> Tuple[str, Any]:
+def _not_like(field: str, value: Any) -> tuple[str, Any]:
     if not isinstance(value, str):
         msg = f"{field}'s value must be a str when using 'LIKE' "
         raise FilterError(msg)

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/tests/conftest.py

@@ -80,11 +80,15 @@ def document_store_w_halfvec_hnsw_index(request, monkeypatch):
 
 @pytest.fixture
 def patches_for_unit_tests():
-    with patch("haystack_integrations.document_stores.pgvector.document_store.register_vector") as mock_register, patch(
-        "haystack_integrations.document_stores.pgvector.document_store.PgvectorDocumentStore.delete_table"
-    ) as mock_delete, patch(
-        "haystack_integrations.document_stores.pgvector.document_store.PgvectorDocumentStore._handle_hnsw"
-    ) as mock_hnsw:
+    with (
+        patch("haystack_integrations.document_stores.pgvector.document_store.register_vector") as mock_register,
+        patch(
+            "haystack_integrations.document_stores.pgvector.document_store.PgvectorDocumentStore.delete_table"
+        ) as mock_delete,
+        patch(
+            "haystack_integrations.document_stores.pgvector.document_store.PgvectorDocumentStore._handle_hnsw"
+        ) as mock_hnsw,
+    ):
         yield mock_register, mock_delete, mock_hnsw
 
 

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/tests/test_document_store.py

@@ -7,7 +7,7 @@ from unittest.mock import patch
 import psycopg
 import pytest
 from haystack.dataclasses.document import ByteStream, Document
-from haystack.document_stores.errors import DuplicateDocumentError
+from haystack.document_stores.errors import DocumentStoreError, DuplicateDocumentError
 from haystack.document_stores.types import DuplicatePolicy
 from haystack.testing.document_store import CountDocumentsTest, DeleteDocumentsTest, WriteDocumentsTest
 from haystack.utils import Secret
@@ -60,6 +60,13 @@ class TestDocumentStore(CountDocumentsTest, WriteDocumentsTest, DeleteDocumentsT
         document_store.write_documents([Document(id="1")])
         assert document_store.count_documents() == 1
 
+    def test_invalid_connection_string(self, monkeypatch):
+        monkeypatch.setenv("PG_CONN_STR", "invalid_connection_string")
+        document_store = PgvectorDocumentStore()
+        with pytest.raises(DocumentStoreError) as e:
+            document_store._ensure_db_setup()
+        assert "Failed to connect to PostgreSQL database" in str(e)
+
 
 @pytest.mark.usefixtures("patches_for_unit_tests")
 def test_init(monkeypatch):

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/tests/test_document_store_async.py

@@ -7,7 +7,7 @@ from unittest.mock import patch
 import psycopg
 import pytest
 from haystack.dataclasses.document import ByteStream, Document
-from haystack.document_stores.errors import DuplicateDocumentError
+from haystack.document_stores.errors import DocumentStoreError, DuplicateDocumentError
 from haystack.document_stores.types import DuplicatePolicy
 from haystack.utils import Secret
 from psycopg.sql import SQL
@@ -101,6 +101,13 @@ class TestDocumentStoreAsync:
         document_store.write_documents([Document(id="1")])
         assert document_store.count_documents() == 1
 
+    async def test_invalid_connection_string(self, monkeypatch):
+        monkeypatch.setenv("PG_CONN_STR", "invalid_connection_string")
+        document_store = PgvectorDocumentStore()
+        with pytest.raises(DocumentStoreError) as e:
+            await document_store._ensure_db_setup_async()
+        assert "Failed to connect to PostgreSQL database" in str(e)
+
 
 @pytest.mark.integration
 @pytest.mark.asyncio

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/tests/test_filters.py

@@ -1,5 +1,3 @@
-from typing import List
-
 import pytest
 from haystack.dataclasses.document import Document
 from haystack.testing.document_store import FilterDocumentsTest
@@ -17,7 +15,7 @@ from haystack_integrations.document_stores.pgvector.filters import (
 
 @pytest.mark.integration
 class TestFilters(FilterDocumentsTest):
-    def assert_documents_are_equal(self, received: List[Document], expected: List[Document]):
+    def assert_documents_are_equal(self, received: list[Document], expected: list[Document]):
         """
         This overrides the default assert_documents_are_equal from FilterDocumentsTest.
         It is needed because the embeddings are not exactly the same when they are retrieved from Postgres.

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/tests/test_retrieval.py

@@ -2,8 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import List
-
 import pytest
 from haystack.dataclasses.document import Document
 from numpy.random import rand
@@ -101,7 +99,7 @@ class TestEmbeddingRetrieval:
         assert results[0].score > results[1].score > results[2].score
 
     def test_empty_query_embedding(self, document_store: PgvectorDocumentStore):
-        query_embedding: List[float] = []
+        query_embedding: list[float] = []
         with pytest.raises(ValueError):
             document_store._embedding_retrieval(query_embedding=query_embedding)
 

{pgvector_haystack-5.3.0 → pgvector_haystack-5.4.0}/tests/test_retrieval_async.py

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import List
 
 import pytest
 from haystack.dataclasses.document import Document
@@ -104,7 +103,7 @@ class TestEmbeddingRetrievalAsync:
         assert results[0].score > results[1].score > results[2].score
 
     async def test_empty_query_embedding_async(self, document_store: PgvectorDocumentStore):
-        query_embedding: List[float] = []
+        query_embedding: list[float] = []
         with pytest.raises(ValueError):
             await document_store._embedding_retrieval_async(query_embedding=query_embedding)
 

pgvector_haystack-5.3.0/pydoc/config.yml

@@ -1,31 +0,0 @@
-loaders:
-  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
-    search_path: [../src]
-    modules: [
-      "haystack_integrations.components.retrievers.pgvector.embedding_retriever",
-      "haystack_integrations.components.retrievers.pgvector.keyword_retriever",
-      "haystack_integrations.document_stores.pgvector.document_store",
-    ]
-    ignore_when_discovered: ["__init__"]
-processors:
-  - type: filter
-    expression:
-    documented_only: true
-    do_not_filter_modules: false
-    skip_empty_modules: true
-  - type: smart
-  - type: crossref
-renderer:
-  type: haystack_pydoc_tools.renderers.ReadmeIntegrationRenderer
-  excerpt: Pgvector integration for Haystack
-  category_slug: integrations-api
-  title: Pgvector
-  slug: integrations-pgvector
-  order: 190
-  markdown:
-    descriptive_class_title: false
-    classdef_code_block: false
-    descriptive_module_title: true
-    add_method_class_prefix: true
-    add_member_class_prefix: false
-    filename: _readme_pgvector.md