sie-haystack 0.8.2__tar.gz → 0.9.0__tar.gz

{sie_haystack-0.8.2 → sie_haystack-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sie-haystack
-Version: 0.8.2
+Version: 0.9.0
 Summary: SIE integration for Haystack
 Author-email: Superlinked <dev@superlinked.com>
 License: Apache-2.0

{sie_haystack-0.8.2 → sie_haystack-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sie-haystack"
-version = "0.8.2"
+version = "0.9.0"
 description = "SIE integration for Haystack"
 readme = "README.md"
 requires-python = ">=3.10"

{sie_haystack-0.8.2 → sie_haystack-0.9.0}/src/sie_haystack/extractors.py

@@ -6,13 +6,23 @@ and detected objects from text.
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import Any
 
 from haystack import component
+from sie_sdk import RequestError
 from sie_sdk.types import Item
 
 
+def _raise_for_item_error(result: Any) -> None:
+    """Raise when SIE reports that extraction failed for this item."""
+    error = result.get("error") if isinstance(result, Mapping) else None
+    if isinstance(error, Mapping):
+        msg = f"Extraction failed: {error.get('message')}"
+        raise RequestError(msg, code=error.get("code"), request=result.get("request"))
+
+
 @dataclass
 class Entity:
     """Extracted entity with position and label information."""
@@ -162,6 +172,7 @@ class SIEExtractor:
             Item(text=text, metadata=metadata),
             labels=effective_labels,
         )
+        _raise_for_item_error(result)
 
         return {
             "entities": self._build_entities(result),

{sie_haystack-0.8.2 → sie_haystack-0.9.0}/src/sie_haystack/rankers.py

@@ -14,10 +14,11 @@ from haystack import Document, component
 def _scores_by_index(results: Mapping[str, Any], count: int) -> list[float]:
     """Map ScoreResult entries back to input positions by item_id.
 
-    Parses each entry's ``item_id`` defensively: a missing, non-integer,
-    negative, or out-of-range id is skipped (that document keeps its 0.0
-    default) so a malformed entry can neither crash the rerank nor mis-assign a
-    score to the wrong document.
+    Each input is sent with ``id=str(position)``, which the server echoes as
+    the entry's ``item_id``. Only an exact echo of a sent id is used: an entry
+    whose ``item_id`` is missing, not a string, or not a sent id is skipped
+    (that document keeps its 0.0 default), so a malformed entry can neither
+    crash the rerank nor mis-assign a score to the wrong document.
 
     Args:
         results: ScoreResult envelope from ``SIEClient.score()``.
@@ -26,25 +27,12 @@ def _scores_by_index(results: Mapping[str, Any], count: int) -> list[float]:
     Returns:
         Scores indexed by input position (0.0 for any unscored/invalid item).
     """
+    positions = {str(index): index for index in range(count)}
     scores = [0.0] * count
     for entry in results.get("scores", []):
-        item_id = entry.get("item_id", entry.get("index"))
-        # Accept only a genuine integer or an integer string. Reject bool (an int
-        # subclass, int(True) == 1), float (int(1.5) == 1), and non-integer
-        # strings, so a malformed id cannot silently overwrite the wrong position.
-        if isinstance(item_id, bool):
-            continue
-        if isinstance(item_id, int):
-            idx = item_id
-        elif isinstance(item_id, str):
-            try:
-                idx = int(item_id)
-            except ValueError:
-                continue
-        else:
-            continue
-        if 0 <= idx < count:
-            scores[idx] = float(entry.get("score", 0.0))
+        item_id = entry.get("item_id")
+        if isinstance(item_id, str) and item_id in positions:
+            scores[positions[item_id]] = float(entry.get("score", 0.0))
     return scores
 
 
@@ -141,18 +129,19 @@ class SIERanker:
 
         # Prepare items
         query_item = Item(text=query)
-        doc_items = [Item(text=doc.content or "") for doc in documents]
+        doc_items = [Item(text=doc.content or "", id=str(idx)) for idx, doc in enumerate(documents)]
 
         # Score documents
         results = self.client.score(self._model, query_item, doc_items)
 
         # ``results`` is a ScoreResult envelope; ranked entries are under
-        # ``results["scores"]`` (each a ScoreEntry keyed by ``item_id`` = input
-        # position, plus ``score``). Map scores back to input order by item_id
-        # rather than zipping positionally — the entries are sorted by relevance,
-        # not by input order. The envelope also carries ``results["request"]``
-        # (request id) and ``results["usage"]`` (token usage); those are
-        # available but intentionally not surfaced through the Haystack contract.
+        # ``results["scores"]`` (each a ScoreEntry whose ``item_id`` echoes the
+        # input position sent as the item ``id``, plus ``score``). Map scores
+        # back to input order by item_id rather than zipping positionally — the
+        # entries are sorted by relevance, not by input order. The envelope also
+        # carries ``results["request"]`` (request id) and ``results["usage"]``
+        # (token usage); those are available but intentionally not surfaced
+        # through the Haystack contract.
         score_by_index = _scores_by_index(results, len(documents))
 
         # Build scored documents

{sie_haystack-0.8.2 → sie_haystack-0.9.0}/tests/conftest.py

@@ -7,11 +7,12 @@ Haystack-specific helpers.
 from __future__ import annotations
 
 from typing import Any
-from unittest.mock import MagicMock
+from unittest.mock import NonCallableMagicMock, create_autospec
 
 import numpy as np
 import pytest
 from haystack import Document
+from sie_sdk import SIEClient
 
 # Default test configuration (matches shared conftest)
 DEFAULT_EMBEDDING_DIM = 384
@@ -84,6 +85,12 @@ def _create_mock_encode_result(
     return result
 
 
+def _server_item_id(item: Any, index: int) -> str:
+    """Return the ``item_id`` the SIE server reports: the sent ``id``, else ``item-<index>``."""
+    item_id = item.get("id") if isinstance(item, dict) else None
+    return item_id if item_id is not None else f"item-{index}"
+
+
 def _create_mock_score_result(query: str, items: list[dict], top_k: int | None = None) -> list[dict[str, Any]]:
     """Create mock score results."""
     rng = np.random.default_rng(hash(query) % (2**32))
@@ -127,9 +134,9 @@ def _create_mock_extract_result(text: str, labels: list[str]) -> list[dict[str,
 
 
 @pytest.fixture
-def mock_sie_client() -> MagicMock:
+def mock_sie_client() -> NonCallableMagicMock:
     """Create a mocked SIEClient for unit testing."""
-    client = MagicMock()
+    client = create_autospec(SIEClient, instance=True)
 
     def mock_encode(_model: str, items: Any, **kwargs: Any) -> list[dict] | dict:
         # Check output_types to determine what to include
@@ -159,10 +166,7 @@ def mock_sie_client() -> MagicMock:
         # Mirror the real SDK: a ScoreResult envelope with ranked entries under
         # "scores", not a bare list.
         query_text = _get_text(query)
-        item_dicts = [
-            {"id": i.get("id", str(idx)) if isinstance(i, dict) else str(idx), "text": _get_text(i)}
-            for idx, i in enumerate(items)
-        ]
+        item_dicts = [{"id": _server_item_id(i, idx), "text": _get_text(i)} for idx, i in enumerate(items)]
         return {
             "model": _model,
             "scores": _create_mock_score_result(query_text, item_dicts, kwargs.get("top_k")),
@@ -176,9 +180,9 @@ def mock_sie_client() -> MagicMock:
             return _create_mock_extract_result(_get_text(items), labels)
         return [_create_mock_extract_result(_get_text(item), labels) for item in items]
 
-    client.encode = MagicMock(side_effect=mock_encode)
-    client.score = MagicMock(side_effect=mock_score)
-    client.extract = MagicMock(side_effect=mock_extract)
+    client.encode.side_effect = mock_encode
+    client.score.side_effect = mock_score
+    client.extract.side_effect = mock_extract
     client.base_url = "http://localhost:8080"
 
     return client

{sie_haystack-0.8.2 → sie_haystack-0.9.0}/tests/test_extractors.py

@@ -2,8 +2,12 @@
 
 from __future__ import annotations
 
+from unittest.mock import NonCallableMagicMock
+
+import pytest
 from sie_haystack import SIEExtractor
 from sie_haystack.extractors import Entity
+from sie_sdk import RequestError
 
 
 class TestSIEExtractor:
@@ -116,3 +120,21 @@ class TestSIEExtractor:
         assert entity.score == 0.95
         assert entity.start == 0
         assert entity.end == 10
+
+
+def test_run_raises_on_item_error(mock_sie_client: NonCallableMagicMock, extract_item_error: dict[str, str]) -> None:
+    mock_sie_client.extract.side_effect = None
+    mock_sie_client.extract.return_value = {
+        "entities": [],
+        "relations": [],
+        "classifications": [],
+        "objects": [],
+        "error": dict(extract_item_error),
+    }
+    extractor = SIEExtractor(model="test-extractor")
+    extractor._client = mock_sie_client
+
+    with pytest.raises(RequestError, match="Extraction failed") as excinfo:
+        extractor.run(text="text")
+
+    assert excinfo.value.code == extract_item_error["code"]

{sie_haystack-0.8.2 → sie_haystack-0.9.0}/tests/test_integration.py

@@ -161,10 +161,7 @@ class TestChromaIntegration:
 
         # 1. Set up Chroma (ephemeral for test)
         _ = chromadb.Client()  # Ensure ephemeral client
-        document_store = ChromaDocumentStore(
-            collection_name="test_sie_haystack",
-            embedding_function=None,  # We provide embeddings via SIE
-        )
+        document_store = ChromaDocumentStore(collection_name="test_sie_haystack")
 
         # 2. Create and embed documents
         doc_embedder = SIEDocumentEmbedder(base_url=sie_url, model="BAAI/bge-m3")

{sie_haystack-0.8.2 → sie_haystack-0.9.0}/tests/test_rankers.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections import Counter
-from unittest.mock import MagicMock
+from typing import Any
 
 from haystack import Document
 from sie_haystack import SIERanker
@@ -70,7 +70,8 @@ class TestSIERanker:
     def test_run_maps_scores_by_item_id(self, mock_sie_client: object) -> None:
         """Top-ranked document is the relevant one, scores mapped by item_id."""
         documents = [Document(content=f"doc-{i}") for i in range(5)]
-        mock_sie_client.score = MagicMock(return_value=_RANKED_ENVELOPE)
+        mock_sie_client.score.side_effect = None
+        mock_sie_client.score.return_value = _RANKED_ENVELOPE
         ranker = SIERanker(model="test-reranker")
         ranker._client = mock_sie_client
 
@@ -83,7 +84,8 @@ class TestSIERanker:
     def test_run_skips_malformed_item_id(self, mock_sie_client: object) -> None:
         """Malformed item_ids are skipped (no crash, no misassignment)."""
         documents = [Document(content=f"doc-{i}") for i in range(3)]
-        mock_sie_client.score = MagicMock(return_value=_MALFORMED_ENVELOPE)
+        mock_sie_client.score.side_effect = None
+        mock_sie_client.score.return_value = _MALFORMED_ENVELOPE
         ranker = SIERanker(model="test-reranker")
         ranker._client = mock_sie_client
 
@@ -94,6 +96,21 @@ class TestSIERanker:
         assert by_content == {"doc-1": 0.8, "doc-0": 0.0, "doc-2": 0.0}
         assert ranked[0].content == "doc-1"
 
+    def test_run_ranks_through_sie_client(self, score_stub_server: Any) -> None:
+        """Scores returned by a real ``SIEClient.score()`` call rank the matching document first."""
+        documents = [
+            Document(content="The weather today is sunny with clear skies."),
+            Document(content="Python is a popular programming language."),
+            Document(content="Nearest neighbor search uses distance metrics."),
+            Document(content="Vector similarity search finds similar embeddings."),
+        ]
+        ranker = SIERanker(base_url=score_stub_server.url, model="test-reranker")
+
+        ranked = ranker.run(query="vector similarity search", documents=documents)["documents"]
+
+        assert [d.content for d in ranked] == [documents[i].content for i in (3, 2, 0, 1)]
+        assert [d.meta["score"] for d in ranked] == [3.0, 1.0, 0.0, 0.0]
+
     def test_run_empty_list(self, mock_sie_client: object) -> None:
         """Test that run handles empty document list."""
         ranker = SIERanker(model="test-reranker")