sentence-transformers-haystack 0.2.0__tar.gz → 2.0.0__tar.gz

{sentence_transformers_haystack-0.2.0 → sentence_transformers_haystack-2.0.0}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [integrations/sentence_transformers-v1.0.0] - 2026-10-16
+
+### 🧹 Chores
+
+- [**breaking**] Drop Python 3.10 support (#4105)
+
+
+## [integrations/sentence_transformers-v0.2.0] - 2026-10-01
+
+### 🐛 Bug Fixes
+
+- Sentence Transformers - raise sentence-transformers floor to >=5.6.0 (CVE-2026-68770) (#4036)
+
+### 📚 Documentation
+
+- Clarify tokenizer_kwargs forwarding in Sentence Transformers components (#4012)
+
+
 ## [integrations/sentence_transformers-v0.1.2] - 2026-09-23
 
 ### 🐛 Bug Fixes

{sentence_transformers_haystack-0.2.0 → sentence_transformers_haystack-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sentence-transformers-haystack
-Version: 0.2.0
+Version: 2.0.0
 Summary: Haystack integration for sentence_transformers
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/sentence_transformers#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
@@ -12,14 +12,13 @@ Keywords: embeddings,haystack,reranking,sentence-transformers
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
-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 :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: haystack-ai>=2.24.0
 Requires-Dist: pillow>=11.3.0
 Requires-Dist: pypdfium2>=4.0.0

{sentence_transformers_haystack-0.2.0 → sentence_transformers_haystack-2.0.0}/pyproject.toml

@@ -7,7 +7,7 @@ name = "sentence-transformers-haystack"
 dynamic = ["version"]
 description = "Haystack integration for sentence_transformers"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = "Apache-2.0"
 keywords = ["haystack", "sentence-transformers", "embeddings", "reranking"]
 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.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",

{sentence_transformers_haystack-0.2.0 → sentence_transformers_haystack-2.0.0}/src/haystack_integrations/components/embedders/sentence_transformers/sentence_transformers_text_embedder.py

@@ -4,7 +4,7 @@
 
 from typing import Any, Literal
 
-from haystack import component, default_from_dict, default_to_dict, logging
+from haystack import component, default_from_dict, default_to_dict
 from haystack.utils import ComponentDevice, Secret
 from haystack.utils.hf import deserialize_hf_model_kwargs, serialize_hf_model_kwargs
 
@@ -13,8 +13,6 @@ from haystack_integrations.components.embedders.sentence_transformers.embedding_
     _SentenceTransformersEmbeddingBackendFactory,
 )
 
-logger = logging.getLogger(__name__)
-
 
 @component
 class SentenceTransformersTextEmbedder:
@@ -122,9 +120,10 @@ class SentenceTransformersTextEmbedder:
         :param quantization_ranges:
             Calibration ranges to use when `precision` is "int8" or "uint8", with shape `(2, embedding_dim)`:
             minimum values in the first row and maximum values in the second.
-            Scalar quantization calibrates the min/max range from the batch being encoded, which is degenerate
-            for a single text and produces meaningless embeddings. Pass ranges computed from a representative
-            sample of embeddings to get consistent quantized embeddings.
+            Required for "int8" and "uint8" because ranges cannot be inferred from a single text.
+            Compute ranges from a representative sample of embeddings.
+        :raises ValueError:
+            `precision` is "int8" or "uint8" and `quantization_ranges` is not provided.
         """
 
         self.model = model
@@ -148,12 +147,11 @@ class SentenceTransformersTextEmbedder:
         self.backend = backend
         self.quantization_ranges = quantization_ranges
         if precision in ("int8", "uint8") and quantization_ranges is None:
-            logger.warning(
-                "Using precision '{precision}' without `quantization_ranges` produces meaningless embeddings for "
-                "single texts, because the calibration range is computed from the batch itself. "
-                "Pass `quantization_ranges` computed from a representative sample of embeddings.",
-                precision=precision,
+            msg = (
+                f"Precision '{precision}' requires `quantization_ranges` computed from "
+                "a representative sample of embeddings."
             )
+            raise ValueError(msg)
 
     def _get_telemetry_data(self) -> dict[str, Any]:
         """

{sentence_transformers_haystack-0.2.0 → sentence_transformers_haystack-2.0.0}/tests/test_sentence_transformers_text_embedder.py

@@ -64,10 +64,10 @@ class TestSentenceTransformersTextEmbedder:
         assert embedder.precision == "int8"
         assert embedder.quantization_ranges == [[-1.0, -1.0], [1.0, 1.0]]
 
-    def test_init_quantized_precision_without_ranges_warns(self, caplog):
-        with caplog.at_level("WARNING"):
-            SentenceTransformersTextEmbedder(model="model", precision="int8")
-        assert "quantization_ranges" in caplog.text
+    @pytest.mark.parametrize("precision", ["int8", "uint8"])
+    def test_init_quantized_precision_without_ranges_raises(self, precision):
+        with pytest.raises(ValueError, match="requires `quantization_ranges`"):
+            SentenceTransformersTextEmbedder(model="model", precision=precision)
 
     def test_to_dict(self):
         component = SentenceTransformersTextEmbedder(model="model", device=ComponentDevice.from_str("cpu"))
@@ -114,6 +114,7 @@ class TestSentenceTransformersTextEmbedder:
             tokenizer_kwargs={"model_max_length": 512},
             config_kwargs={"use_memory_efficient_attention": False},
             precision="int8",
+            quantization_ranges=[[-1.0] * 256, [1.0] * 256],
             encode_kwargs={"task": "clustering"},
         )
         data = component.to_dict()
@@ -138,7 +139,7 @@ class TestSentenceTransformersTextEmbedder:
                 "precision": "int8",
                 "encode_kwargs": {"task": "clustering"},
                 "backend": "torch",
-                "quantization_ranges": None,
+                "quantization_ranges": [[-1.0] * 256, [1.0] * 256],
             },
         }
 
@@ -223,6 +224,7 @@ class TestSentenceTransformersTextEmbedder:
                 "local_files_only": False,
                 "truncate_dim": 256,
                 "precision": "int8",
+                "quantization_ranges": [[-1.0] * 256, [1.0] * 256],
             },
         }
         component = SentenceTransformersTextEmbedder.from_dict(data)
@@ -239,6 +241,7 @@ class TestSentenceTransformersTextEmbedder:
         assert component.local_files_only is False
         assert component.truncate_dim == 256
         assert component.precision == "int8"
+        assert component.quantization_ranges == [[-1.0] * 256, [1.0] * 256]
 
     @patch(
         "haystack_integrations.components.embedders.sentence_transformers.sentence_transformers_text_embedder._SentenceTransformersEmbeddingBackendFactory"
@@ -432,24 +435,6 @@ class TestSentenceTransformersTextEmbedder:
         # without truncation, the embedding has 128 length
         assert len(embedding_trunc) == 64
 
-    @pytest.mark.integration
-    def test_run_quantization(self, del_hf_env_vars_if_empty):
-        """
-        sentence-transformers-testing/stsb-bert-tiny-safetensors maps sentences & paragraphs to a 128 dimensional dense
-        vector space
-        """
-        checkpoint = "sentence-transformers-testing/stsb-bert-tiny-safetensors"
-        text = "a nice text to embed"
-
-        embedder_def = SentenceTransformersTextEmbedder(
-            model=checkpoint, precision="int8", device=ComponentDevice.from_str("cpu")
-        )
-        result_def = embedder_def.run(text=text)
-        embedding_def = result_def["embedding"]
-
-        assert len(embedding_def) == 128
-        assert all(isinstance(el, int) for el in embedding_def)
-
     @pytest.mark.integration
     def test_run_quantization_with_ranges(self, del_hf_env_vars_if_empty):
         """
@@ -466,5 +451,4 @@ class TestSentenceTransformersTextEmbedder:
 
         assert len(embedding) == 128
         assert all(isinstance(el, int) for el in embedding)
-        # without explicit ranges, a single text produces a degenerate all-equal embedding
         assert len(set(embedding)) > 1