pgvector-haystack 5.5.0__tar.gz → 6.0.0__tar.gz

{pgvector_haystack-5.5.0 → pgvector_haystack-6.0.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [integrations/pgvector-v5.5.0] - 2026-01-02
+
+### 🚀 Features
+
+- Adding `update_by_filter` and `delete_by_filter` to PgVector document store (#2647)
+
+
 ## [integrations/pgvector-v5.4.0] - 2025-12-05
 
 ### 📚 Documentation

{pgvector_haystack-5.5.0 → pgvector_haystack-6.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgvector-haystack
-Version: 5.5.0
+Version: 6.0.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
@@ -11,15 +11,14 @@ License-File: LICENSE.txt
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.9
-Requires-Dist: haystack-ai>=2.11.0
+Requires-Python: >=3.10
+Requires-Dist: haystack-ai>=2.22.0
 Requires-Dist: pgvector>=0.3.0
 Requires-Dist: psycopg[binary]
 Description-Content-Type: text/markdown

{pgvector_haystack-5.5.0 → pgvector_haystack-6.0.0}/pyproject.toml

@@ -7,7 +7,7 @@ name = "pgvector-haystack"
 dynamic = ["version"]
 description = "An integration of pgvector (vector search extension for Postgres) with Haystack"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = "Apache-2.0"
 keywords = []
 authors = [{ name = "deepset GmbH", email = "info@deepset.ai" }]
@@ -15,7 +15,6 @@ 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",
@@ -23,7 +22,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.11.0", "pgvector>=0.3.0", "psycopg[binary]"]
+dependencies = ["haystack-ai>=2.22.0", "pgvector>=0.3.0", "psycopg[binary]"]
 
 [project.urls]
 Source = "https://github.com/deepset-ai/haystack-core-integrations"
@@ -47,7 +46,7 @@ dependencies = ["haystack-pydoc-tools", "ruff"]
 
 [tool.hatch.envs.default.scripts]
 docs = ["pydoc-markdown pydoc/config_docusaurus.yml"]
-fmt = "ruff check --fix {args} && ruff format {args}"
+fmt = "ruff check --fix {args}; ruff format {args}"
 fmt-check = "ruff check {args} && ruff format --check {args}"
 
 [tool.hatch.envs.test]
@@ -83,7 +82,6 @@ ignore_missing_imports = true
 
 
 [tool.ruff]
-target-version = "py39"
 line-length = 120
 
 [tool.ruff.lint]
@@ -134,10 +132,6 @@ ignore = [
   # ignore assertions
   "S101",
 ]
-unfixable = [
-  # Don't touch unused imports
-  "F401",
-]
 
 [tool.ruff.lint.isort]
 known-first-party = ["haystack_integrations"]

{pgvector_haystack-5.5.0 → pgvector_haystack-6.0.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, Literal, Optional, Union
+from typing import Any, Literal
 
 from haystack import component, default_from_dict, default_to_dict
 from haystack.dataclasses import Document
@@ -62,10 +62,10 @@ class PgvectorEmbeddingRetriever:
         self,
         *,
         document_store: PgvectorDocumentStore,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
         top_k: int = 10,
-        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
-        filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
+        vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None = None,
+        filter_policy: str | FilterPolicy = FilterPolicy.REPLACE,
     ):
         """
         :param document_store: An instance of `PgvectorDocumentStore`.
@@ -137,9 +137,9 @@ class PgvectorEmbeddingRetriever:
     def run(
         self,
         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,
+        filters: dict[str, Any] | None = None,
+        top_k: int | None = None,
+        vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None = None,
     ) -> dict[str, list[Document]]:
         """
         Retrieve documents from the `PgvectorDocumentStore`, based on their embeddings.
@@ -170,9 +170,9 @@ class PgvectorEmbeddingRetriever:
     async def run_async(
         self,
         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,
+        filters: dict[str, Any] | None = None,
+        top_k: int | None = None,
+        vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None = None,
     ) -> dict[str, list[Document]]:
         """
         Asynchronously retrieve documents from the `PgvectorDocumentStore`, based on their embeddings.

{pgvector_haystack-5.5.0 → pgvector_haystack-6.0.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, Optional, Union
+from typing import Any
 
 from haystack import component, default_from_dict, default_to_dict
 from haystack.dataclasses import Document
@@ -52,9 +52,9 @@ class PgvectorKeywordRetriever:
         self,
         *,
         document_store: PgvectorDocumentStore,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
         top_k: int = 10,
-        filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
+        filter_policy: str | FilterPolicy = FilterPolicy.REPLACE,
     ):
         """
         :param document_store: An instance of `PgvectorDocumentStore`.
@@ -111,8 +111,8 @@ class PgvectorKeywordRetriever:
     def run(
         self,
         query: str,
-        filters: Optional[dict[str, Any]] = None,
-        top_k: Optional[int] = None,
+        filters: dict[str, Any] | None = None,
+        top_k: int | None = None,
     ) -> dict[str, list[Document]]:
         """
         Retrieve documents from the `PgvectorDocumentStore`, based on keywords.
@@ -141,8 +141,8 @@ class PgvectorKeywordRetriever:
     async def run_async(
         self,
         query: str,
-        filters: Optional[dict[str, Any]] = None,
-        top_k: Optional[int] = None,
+        filters: dict[str, Any] | None = None,
+        top_k: int | None = None,
     ) -> dict[str, list[Document]]:
         """
         Asynchronously retrieve documents from the `PgvectorDocumentStore`, based on keywords.

{pgvector_haystack-5.5.0 → pgvector_haystack-6.0.0}/src/haystack_integrations/document_stores/pgvector/document_store.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Literal, Optional, Union, overload
+from typing import Any, Literal, overload
 
 from haystack import default_from_dict, default_to_dict, logging
 from haystack.dataclasses.document import Document
@@ -92,9 +92,9 @@ 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: dict[str, int] | None = None,
         hnsw_index_name: str = "haystack_hnsw_index",
-        hnsw_ef_search: Optional[int] = None,
+        hnsw_ef_search: int | None = None,
         keyword_index_name: str = "haystack_keyword_index",
     ):
         """
@@ -175,12 +175,12 @@ class PgvectorDocumentStore:
         self.keyword_index_name = keyword_index_name
         self.language = language
 
-        self._connection: Optional[Connection] = None
-        self._async_connection: Optional[AsyncConnection] = None
-        self._cursor: Optional[Cursor] = None
-        self._async_cursor: Optional[AsyncCursor] = None
-        self._dict_cursor: Optional[Cursor[DictRow]] = None
-        self._async_dict_cursor: Optional[AsyncCursor[DictRow]] = None
+        self._connection: Connection | None = None
+        self._async_connection: AsyncConnection | None = None
+        self._cursor: Cursor | None = None
+        self._async_cursor: AsyncCursor | None = None
+        self._dict_cursor: Cursor[DictRow] | None = None
+        self._async_dict_cursor: AsyncCursor[DictRow] | None = None
         self._table_initialized = False
 
     def to_dict(self) -> dict[str, Any]:
@@ -250,21 +250,21 @@ class PgvectorDocumentStore:
 
     @overload
     def _execute_sql(
-        self, cursor: Cursor, sql_query: Composed, params: Optional[tuple] = None, error_msg: str = ""
+        self, cursor: Cursor, sql_query: Composed, params: tuple | None = None, error_msg: str = ""
     ) -> Cursor: ...
 
     @overload
     def _execute_sql(
-        self, cursor: Cursor[DictRow], sql_query: Composed, params: Optional[tuple] = None, error_msg: str = ""
+        self, cursor: Cursor[DictRow], sql_query: Composed, params: tuple | None = None, error_msg: str = ""
     ) -> Cursor[DictRow]: ...
 
     def _execute_sql(
         self,
-        cursor: Union[Cursor, Cursor[DictRow]],
+        cursor: Cursor | Cursor[DictRow],
         sql_query: Composed,
-        params: Optional[tuple] = None,
+        params: tuple | None = None,
         error_msg: str = "",
-    ) -> Union[Cursor, Cursor[DictRow]]:
+    ) -> Cursor | Cursor[DictRow]:
         """
         Internal method to execute SQL statements and handle exceptions.
 
@@ -299,21 +299,21 @@ class PgvectorDocumentStore:
 
     @overload
     async def _execute_sql_async(
-        self, cursor: AsyncCursor, sql_query: Composed, params: Optional[tuple] = None, error_msg: str = ""
+        self, cursor: AsyncCursor, sql_query: Composed, params: tuple | None = None, error_msg: str = ""
     ) -> AsyncCursor: ...
 
     @overload
     async def _execute_sql_async(
-        self, cursor: AsyncCursor[DictRow], sql_query: Composed, params: Optional[tuple] = None, error_msg: str = ""
+        self, cursor: AsyncCursor[DictRow], sql_query: Composed, params: tuple | None = None, error_msg: str = ""
     ) -> AsyncCursor[DictRow]: ...
 
     async def _execute_sql_async(
         self,
-        cursor: Union[AsyncCursor, AsyncCursor[DictRow]],
+        cursor: AsyncCursor | AsyncCursor[DictRow],
         sql_query: Composed,
-        params: Optional[tuple] = None,
+        params: tuple | None = None,
         error_msg: str = "",
-    ) -> Union[AsyncCursor, AsyncCursor[DictRow]]:
+    ) -> AsyncCursor | AsyncCursor[DictRow]:
         """
         Internal method to asynchronously execute SQL statements and handle exceptions.
 
@@ -759,12 +759,12 @@ class PgvectorDocumentStore:
             return result[0]
         return 0
 
-    def filter_documents(self, filters: Optional[dict[str, Any]] = None) -> list[Document]:
+    def filter_documents(self, filters: dict[str, Any] | None = None) -> list[Document]:
         """
         Returns the documents that match the filters provided.
 
         For a detailed specification of the filters,
-        refer to the [documentation](https://docs.haystack.deepset.ai/v2.0/docs/metadata-filtering)
+        refer to the [documentation](https://docs.haystack.deepset.ai/docs/metadata-filtering)
 
         :param filters: The filters to apply to the document list.
         :raises TypeError: If `filters` is not a dictionary.
@@ -796,12 +796,12 @@ 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: dict[str, Any] | None = None) -> list[Document]:
         """
         Asynchronously returns the documents that match the filters provided.
 
         For a detailed specification of the filters,
-        refer to the [documentation](https://docs.haystack.deepset.ai/v2.0/docs/metadata-filtering)
+        refer to the [documentation](https://docs.haystack.deepset.ai/docs/metadata-filtering)
 
         :param filters: The filters to apply to the document list.
 
@@ -1223,7 +1223,7 @@ class PgvectorDocumentStore:
             raise DocumentStoreError(msg) from e
 
     def _build_keyword_retrieval_query(
-        self, query: str, top_k: int, filters: Optional[dict[str, Any]] = None
+        self, query: str, top_k: int, filters: dict[str, Any] | None = None
     ) -> tuple[Composed, tuple]:
         """
         Builds the SQL query and the where parameters for keyword retrieval.
@@ -1236,7 +1236,7 @@ class PgvectorDocumentStore:
         )
 
         where_params = ()
-        sql_where_clause: Union[Composed, SQL] = SQL("")
+        sql_where_clause: Composed | SQL = SQL("")
         if filters:
             sql_where_clause, where_params = _convert_filters_to_where_clause_and_params(
                 filters=filters, operator="AND"
@@ -1252,7 +1252,7 @@ class PgvectorDocumentStore:
         self,
         query: str,
         *,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
         top_k: int = 10,
     ) -> list[Document]:
         """
@@ -1287,7 +1287,7 @@ class PgvectorDocumentStore:
         self,
         query: str,
         *,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
         top_k: int = 10,
     ) -> list[Document]:
         """
@@ -1315,9 +1315,9 @@ class PgvectorDocumentStore:
     def _check_and_build_embedding_retrieval_query(
         self,
         query_embedding: list[float],
-        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]],
+        vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None,
         top_k: int,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
     ) -> tuple[Composed, tuple]:
         """
         Performs checks and builds the SQL query and the where parameters for embedding retrieval.
@@ -1357,7 +1357,7 @@ class PgvectorDocumentStore:
             score=SQL(score_definition),
         )
 
-        sql_where_clause: Union[Composed, SQL] = SQL("")
+        sql_where_clause: Composed | SQL = SQL("")
         params = ()
         if filters:
             sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
@@ -1379,9 +1379,9 @@ class PgvectorDocumentStore:
         self,
         query_embedding: list[float],
         *,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
         top_k: int = 10,
-        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
+        vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None = None,
     ) -> list[Document]:
         """
         Retrieves documents that are most similar to the query embedding using a vector similarity metric.
@@ -1413,9 +1413,9 @@ class PgvectorDocumentStore:
         self,
         query_embedding: list[float],
         *,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
         top_k: int = 10,
-        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
+        vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None = None,
     ) -> list[Document]:
         """
         Asynchronously retrieves documents that are most similar to the query embedding using a

{pgvector_haystack-5.5.0 → pgvector_haystack-6.0.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, Literal, Optional
+from typing import Any, Literal
 
 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: dict[str, Any] | None = None) -> None:
     """
     Validates the filters provided.
     """

{pgvector_haystack-5.5.0 → pgvector_haystack-6.0.0}/tests/test_document_store.py

@@ -154,7 +154,7 @@ def test_halfvec_hnsw_write_documents(document_store_w_halfvec_hnsw_index: Pgvec
     retrieved_docs = document_store_w_halfvec_hnsw_index.filter_documents()
     retrieved_docs.sort(key=lambda x: x.id)
 
-    for original_doc, retrieved_doc in zip(documents, retrieved_docs):
+    for original_doc, retrieved_doc in zip(documents, retrieved_docs, strict=True):
         assert original_doc.id == retrieved_doc.id
         assert original_doc.content == retrieved_doc.content
         assert len(original_doc.embedding) == len(retrieved_doc.embedding)

{pgvector_haystack-5.5.0 → pgvector_haystack-6.0.0}/tests/test_filters.py

@@ -24,7 +24,7 @@ class TestFilters(FilterDocumentsTest):
         assert len(received) == len(expected)
         received.sort(key=lambda x: x.id)
         expected.sort(key=lambda x: x.id)
-        for received_doc, expected_doc in zip(received, expected):
+        for received_doc, expected_doc in zip(received, expected, strict=True):
             # we first compare the embeddings approximately
             if received_doc.embedding is None:
                 assert expected_doc.embedding is None