pinecone-haystack 6.2.0__tar.gz → 6.3.0__tar.gz

{pinecone_haystack-6.2.0 → pinecone_haystack-6.3.0}/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [integrations/pinecone-v6.2.0] - 2026-05-08
+
+### 🐛 Bug Fixes
+
+- Replace in-place dataclass mutations in document stores (#3114)
+
+### 🚜 Refactor
+
+- *(pinecone)* Make get_metadata_field_min_max more consistent; use async DocumentStore mixin tests (#3231)
+
+### 📚 Documentation
+
+- Simplify pydoc configs (#2855)
+
+### 🧪 Testing
+
+- Replacing each `DocumentStore` specific tests and used the generalised ones from `haystack.testing.document_store` (#2812)
+- Test compatible integrations with python 3.14; update pyproject (#3001)
+- `PineconeDocumentStore` use Mixin tests (#3020)
+- Track test coverage for all integrations (#3065)
+- Pinecone - add unit tests (#3218)
+- Pinecone - remove namespaces when tests ends (#3248)
+
+### 🧹 Chores
+
+- Exposing `PineconeDocumentStore` `show_progress` bar parameter and disabling it for tests (#2799)
+- Remove unused allow-direct-references (#2866)
+- Add ANN ruff ruleset to optimum, paddleocr, pgvector, pinecone, pyversity, qdrant, ragas, snowflake (#2992)
+- Enforce ruff docstring rules in integrations 31-40 (openrouter, opensearch, optimum, paddleocr, pgvector, pinecone, pyversity, qdrant, ragas, snowflake) (#3011)
+- Pinecone - fix types for Pinecone 9 (#3277)
+
+
 ## [integrations/pinecone-v6.1.2] - 2026-01-28
 
 ### 🐛 Bug Fixes

{pinecone_haystack-6.2.0 → pinecone_haystack-6.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pinecone_haystack
-Version: 6.2.0
+Version: 6.3.0
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/pinecone#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
 Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/pinecone

{pinecone_haystack-6.2.0 → pinecone_haystack-6.3.0}/examples/example.py

@@ -12,11 +12,14 @@ import glob
 
 from haystack import Pipeline
 from haystack.components.converters import MarkdownToDocument
-from haystack.components.embedders import SentenceTransformersDocumentEmbedder, SentenceTransformersTextEmbedder
 from haystack.components.preprocessors import DocumentSplitter
 from haystack.components.writers import DocumentWriter
 from haystack.utils import Secret
 
+from haystack_integrations.components.embedders.sentence_transformers import (
+    SentenceTransformersDocumentEmbedder,
+    SentenceTransformersTextEmbedder,
+)
 from haystack_integrations.components.retrievers.pinecone import PineconeEmbeddingRetriever
 from haystack_integrations.document_stores.pinecone import PineconeDocumentStore
 

{pinecone_haystack-6.2.0 → pinecone_haystack-6.3.0}/src/haystack_integrations/components/retrievers/pinecone/embedding_retriever.py

@@ -22,7 +22,9 @@ class PineconeEmbeddingRetriever:
     from haystack.document_stores.types import DuplicatePolicy
     from haystack import Document
     from haystack import Pipeline
-    from haystack.components.embedders import SentenceTransformersTextEmbedder, SentenceTransformersDocumentEmbedder
+    # Requires: pip install sentence-transformers-haystack
+    from haystack_integrations.components.embedders.sentence_transformers import SentenceTransformersTextEmbedder
+    from haystack_integrations.components.embedders.sentence_transformers import SentenceTransformersDocumentEmbedder
     from haystack_integrations.components.retrievers.pinecone import PineconeEmbeddingRetriever
     from haystack_integrations.document_stores.pinecone import PineconeDocumentStore
 
@@ -34,7 +36,6 @@ class PineconeEmbeddingRetriever:
                  Document(content="In certain places, you can witness the phenomenon of bioluminescent waves.")]
 
     document_embedder = SentenceTransformersDocumentEmbedder()
-    document_embedder.warm_up()
     documents_with_embeddings = document_embedder.run(documents)
 
     document_store.write_documents(documents_with_embeddings.get("documents"), policy=DuplicatePolicy.OVERWRITE)
@@ -114,6 +115,18 @@ class PineconeEmbeddingRetriever:
             data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(filter_policy)
         return default_from_dict(cls, data)
 
+    def close(self) -> None:
+        """
+        Release the synchronous resources of the underlying Document Store.
+        """
+        self.document_store.close()
+
+    async def close_async(self) -> None:
+        """
+        Release the asynchronous resources of the underlying Document Store.
+        """
+        await self.document_store.close_async()
+
     @component.output_types(documents=list[Document])
     def run(
         self,

{pinecone_haystack-6.2.0 → pinecone_haystack-6.3.0}/src/haystack_integrations/document_stores/pinecone/document_store.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from contextlib import suppress
 from copy import copy
 from dataclasses import replace
 from typing import Any, Literal
@@ -151,18 +152,20 @@ class PineconeDocumentStore:
 
     def close(self) -> None:
         """
-        Close the associated synchronous resources.
+        Release the associated synchronous resources.
         """
-        if self._index:
-            self._index.close()
+        if self._index is not None:
+            with suppress(Exception):
+                self._index.close()
             self._index = None
 
     async def close_async(self) -> None:
         """
-        Close the associated asynchronous resources. To be invoked manually when the Document Store is no longer needed.
+        Release the associated asynchronous resources.
         """
-        if self._async_index:
-            await self._async_index.close()
+        if self._async_index is not None:
+            with suppress(Exception):
+                await self._async_index.close()
             self._async_index = None
 
     @staticmethod

{pinecone_haystack-6.2.0 → pinecone_haystack-6.3.0}/tests/test_document_store.py

@@ -4,7 +4,8 @@
 
 import os
 import time
-from unittest.mock import patch
+from dataclasses import replace
+from unittest.mock import MagicMock, patch
 
 import numpy as np
 import pytest
@@ -127,7 +128,31 @@ def test_to_from_dict(mock_pinecone, monkeypatch):
     assert document_store.dimension == 60
     assert document_store.metric == "euclidean"
     assert document_store.spec == {"serverless": {"region": "us-east-1", "cloud": "aws"}}
-    assert document_store.show_progress is True
+
+
+def test_close():
+    document_store = PineconeDocumentStore(api_key=Secret.from_token("fake-api-key"))
+    mock_index = MagicMock()
+    document_store._index = mock_index
+
+    document_store.close()
+
+    mock_index.close.assert_called_once()
+    assert document_store._index is None
+
+    document_store.close()
+    mock_index.close.assert_called_once()
+
+
+def test_close_is_exception_safe():
+    document_store = PineconeDocumentStore(api_key=Secret.from_token("fake-api-key"))
+    mock_index = MagicMock()
+    mock_index.close.side_effect = RuntimeError("boom")
+    document_store._index = mock_index
+
+    document_store.close()
+
+    assert document_store._index is None
 
 
 def test_init_fails_wo_api_key(monkeypatch):
@@ -340,22 +365,6 @@ def test_prepare_documents_for_writing_edge_cases(caplog):
     assert "sparse_embedding" in caplog.text
 
 
-@pytest.mark.asyncio
-async def test_validation_errors_on_empty_query_and_non_dict_meta():
-    ds = PineconeDocumentStore(api_key=Secret.from_token("fake-api-key"))
-    filters = {"field": "meta.category", "operator": "==", "value": "A"}
-
-    with pytest.raises(ValueError, match="query_embedding must be a non-empty list"):
-        ds._embedding_retrieval(query_embedding=[])
-    with pytest.raises(ValueError, match="query_embedding must be a non-empty list"):
-        await ds._embedding_retrieval_async(query_embedding=[])
-
-    with pytest.raises(ValueError, match="meta must be a dictionary"):
-        ds.update_by_filter(filters=filters, meta="not-a-dict")
-    with pytest.raises(ValueError, match="meta must be a dictionary"):
-        await ds.update_by_filter_async(filters=filters, meta="not-a-dict")
-
-
 @pytest.mark.integration
 @pytest.mark.skipif(not os.environ.get("PINECONE_API_KEY"), reason="PINECONE_API_KEY not set")
 def test_serverless_index_creation_from_scratch(delete_sleep_time):
@@ -452,7 +461,7 @@ class TestDocumentStore(
         assert "Most similar document" in [result.content for result in results]
         assert "2nd best document" in [result.content for result in results]
 
-    def test_close(self, document_store: PineconeDocumentStore):
+    def test_close_and_reopen(self, document_store: PineconeDocumentStore):
         document_store._initialize_index()
         assert document_store._index is not None
 
@@ -461,7 +470,6 @@ class TestDocumentStore(
 
         document_store._initialize_index()
         assert document_store._index is not None
-        # test that the index is still usable after closing and reopening
         assert document_store.count_documents() == 0
 
     def test_sentence_window_retriever(self, document_store: PineconeDocumentStore):
@@ -475,9 +483,9 @@ class TestDocumentStore(
 
         for idx, doc in enumerate(docs["documents"]):
             if idx == 2:
-                doc.embedding = [0.1] * 768
+                docs["documents"][idx] = replace(doc, embedding=[0.1] * 768)
                 continue
-            doc.embedding = np.random.rand(768).tolist()
+            docs["documents"][idx] = replace(doc, embedding=np.random.rand(768).tolist())
         document_store.write_documents(docs["documents"])
 
         # query

{pinecone_haystack-6.2.0 → pinecone_haystack-6.3.0}/tests/test_document_store_async.py

@@ -4,6 +4,7 @@
 
 import os
 from dataclasses import replace
+from unittest.mock import AsyncMock
 
 import numpy as np
 import pytest
@@ -25,11 +26,55 @@ from haystack.testing.document_store_async import (
     UpdateByFilterAsyncTest,
     WriteDocumentsAsyncTest,
 )
+from haystack.utils import Secret
 
 from haystack_integrations.components.retrievers.pinecone import PineconeEmbeddingRetriever
 from haystack_integrations.document_stores.pinecone import PineconeDocumentStore
 
 
+@pytest.mark.asyncio
+async def test_close_async():
+    document_store = PineconeDocumentStore(api_key=Secret.from_token("fake-api-key"))
+    mock_index = AsyncMock()
+    document_store._async_index = mock_index
+
+    await document_store.close_async()
+
+    mock_index.close.assert_awaited_once()
+    assert document_store._async_index is None
+
+    await document_store.close_async()
+    mock_index.close.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_close_async_is_exception_safe():
+    document_store = PineconeDocumentStore(api_key=Secret.from_token("fake-api-key"))
+    mock_index = AsyncMock()
+    mock_index.close.side_effect = RuntimeError("boom")
+    document_store._async_index = mock_index
+
+    await document_store.close_async()
+
+    assert document_store._async_index is None
+
+
+@pytest.mark.asyncio
+async def test_validation_errors_on_empty_query_and_non_dict_meta():
+    ds = PineconeDocumentStore(api_key=Secret.from_token("fake-api-key"))
+    filters = {"field": "meta.category", "operator": "==", "value": "A"}
+
+    with pytest.raises(ValueError, match="query_embedding must be a non-empty list"):
+        ds._embedding_retrieval(query_embedding=[])
+    with pytest.raises(ValueError, match="query_embedding must be a non-empty list"):
+        await ds._embedding_retrieval_async(query_embedding=[])
+
+    with pytest.raises(ValueError, match="meta must be a dictionary"):
+        ds.update_by_filter(filters=filters, meta="not-a-dict")
+    with pytest.raises(ValueError, match="meta must be a dictionary"):
+        await ds.update_by_filter_async(filters=filters, meta="not-a-dict")
+
+
 @pytest.mark.integration
 @pytest.mark.asyncio
 @pytest.mark.skipif(not os.environ.get("PINECONE_API_KEY"), reason="PINECONE_API_KEY not set")
@@ -114,7 +159,7 @@ class TestDocumentStoreAsync(
         assert "Most similar document" in [result.content for result in results]
         assert "2nd best document" in [result.content for result in results]
 
-    async def test_close(self, document_store_async: PineconeDocumentStore):
+    async def test_close_async_and_reopen(self, document_store_async: PineconeDocumentStore):
         await document_store_async._initialize_async_index()
         assert document_store_async._async_index is not None
 
@@ -123,7 +168,6 @@ class TestDocumentStoreAsync(
 
         await document_store_async._initialize_async_index()
         assert document_store_async._async_index is not None
-        # test that the index is still usable after closing and reopening
         assert await document_store_async.count_documents_async() == 0
 
     async def test_sentence_window_retriever(self, document_store_async: PineconeDocumentStore):
@@ -137,9 +181,9 @@ class TestDocumentStoreAsync(
 
         for idx, doc in enumerate(docs["documents"]):
             if idx == 2:
-                doc.embedding = [0.1] * 768
+                docs["documents"][idx] = replace(doc, embedding=[0.1] * 768)
                 continue
-            doc.embedding = np.random.rand(768).tolist()
+            docs["documents"][idx] = replace(doc, embedding=np.random.rand(768).tolist())
         await document_store_async.write_documents_async(docs["documents"])
 
         # query

{pinecone_haystack-6.2.0 → pinecone_haystack-6.3.0}/tests/test_embedding_retriever.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from unittest.mock import Mock, patch
+from unittest.mock import AsyncMock, Mock, patch
 
 import pytest
 from haystack.dataclasses import Document
@@ -33,6 +33,28 @@ def test_init_raises_for_non_pinecone_document_store():
         PineconeEmbeddingRetriever(document_store="not-a-document-store")
 
 
+def test_close():
+    mock_store = Mock(spec=PineconeDocumentStore)
+    retriever = PineconeEmbeddingRetriever(document_store=mock_store)
+
+    retriever.close()
+
+    mock_store.close.assert_called_once_with()
+    assert retriever.document_store is mock_store
+
+
+@pytest.mark.asyncio
+async def test_close_async():
+    mock_store = Mock(spec=PineconeDocumentStore)
+    mock_store.close_async = AsyncMock()
+    retriever = PineconeEmbeddingRetriever(document_store=mock_store)
+
+    await retriever.close_async()
+
+    mock_store.close_async.assert_awaited_once_with()
+    assert retriever.document_store is mock_store
+
+
 @patch("haystack_integrations.document_stores.pinecone.document_store.Pinecone")
 def test_to_dict(mock_pinecone, monkeypatch):
     monkeypatch.setenv("PINECONE_API_KEY", "env-api-key")