huggingface-api-haystack 2.0.0__tar.gz → 3.0.0__tar.gz

{huggingface_api_haystack-2.0.0 → huggingface_api_haystack-3.0.0}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [integrations/huggingface_api-v2.1.0] - 2026-10-06
+
+### 🚜 Refactor
+
+- [**breaking**] HF API - Stop warming up tools in Chat Generator (#4056)
+
+
+## [integrations/huggingface_api-v2.0.0] - 2026-10-01
+
+### 🚀 Features
+
+- [**breaking**] Add grpc support for the huggingface TEI components; rename HuggingFace API Sparse Embedders -> Hugging Face TEI Sparse Embedders (#3870)
+
+### 🧪 Testing
+
+- HF API - use Groq for gpt-oss-20b (#4001)
+
+
 ## [integrations/huggingface_api-v1.0.0] - 2026-09-07
 
 ### 🚀 Features

{huggingface_api_haystack-2.0.0 → huggingface_api_haystack-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: huggingface-api-haystack
-Version: 2.0.0
+Version: 3.0.0
 Summary: Haystack integration for Hugging Face API
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/huggingface_api#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
@@ -11,14 +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.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 :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: haystack-ai>=3.0.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: huggingface-hub[inference]>=1.0.0

{huggingface_api_haystack-2.0.0 → huggingface_api_haystack-3.0.0}/pyproject.toml

@@ -7,7 +7,7 @@ name = "huggingface-api-haystack"
 dynamic = ["version"]
 description = "Haystack integration for Hugging Face API"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = "Apache-2.0"
 keywords = []
 authors = [{ name = "deepset GmbH", email = "info@deepset.ai" }]
@@ -15,11 +15,11 @@ 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",
   "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]

{huggingface_api_haystack-2.0.0 → huggingface_api_haystack-3.0.0}/src/haystack_integrations/components/generators/huggingface_api/chat/chat_generator.py

@@ -5,7 +5,7 @@
 import inspect
 import json
 from collections.abc import AsyncIterable, Iterable
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from typing import Any, Union
 
 from haystack import component, default_from_dict, default_to_dict, logging
@@ -27,7 +27,6 @@ from haystack.tools import (
     deserialize_tools_or_toolset_inplace,
     flatten_tools_or_toolsets,
     serialize_tools_or_toolset,
-    warm_up_tools,
 )
 from haystack.utils import Secret, deserialize_callable, serialize_callable
 from haystack.utils.hf import convert_message_to_hf_format
@@ -222,7 +221,7 @@ def _convert_chat_completion_stream_output_to_streaming_chunk(
             usage = {"prompt_tokens": chunk.usage.prompt_tokens, "completion_tokens": chunk.usage.completion_tokens}
         return StreamingChunk(
             content="",
-            meta={"model": chunk.model, "received_at": datetime.now(timezone.utc).isoformat(), "usage": usage},
+            meta={"model": chunk.model, "received_at": datetime.now(UTC).isoformat(), "usage": usage},
             component_info=component_info,
         )
 
@@ -239,7 +238,7 @@ def _convert_chat_completion_stream_output_to_streaming_chunk(
         content=choice.delta.content or "",
         meta={
             "model": chunk.model,
-            "received_at": datetime.now(timezone.utc).isoformat(),
+            "received_at": datetime.now(UTC).isoformat(),
             "finish_reason": choice.finish_reason,
         },
         component_info=component_info,
@@ -442,7 +441,6 @@ class HuggingFaceAPIChatGenerator:
         self._model_or_url = model_or_url
         self._client: InferenceClient | None = None
         self._async_client: AsyncInferenceClient | None = None
-        self._tools_warmed_up = False
 
     def _client_kwargs(self) -> dict[str, Any]:
         """Build the keyword arguments used to create Hugging Face clients."""
@@ -452,26 +450,15 @@ class HuggingFaceAPIChatGenerator:
             **{k: v for k, v in self.api_params.items() if k not in ("model", "url")},
         }
 
-    def _warm_up_tools(self) -> None:
-        if not self._tools_warmed_up:
-            warm_up_tools(self.tools)
-            self._tools_warmed_up = True
-
     def warm_up(self) -> None:
-        """
-        Warm up the Hugging Face API chat generator.
-
-        This creates the synchronous client and warms up the configured tools.
-        """
-        self._warm_up_tools()
+        """Create the synchronous Hugging Face client."""
         if self._client is None:
             if self.api_type == HFGenerationAPIType.SERVERLESS_INFERENCE_API:
                 _check_valid_model(self._model_or_url, HFModelType.GENERATION, self.token)
             self._client = InferenceClient(**self._client_kwargs())
 
     async def warm_up_async(self) -> None:
-        """Create the asynchronous Hugging Face client and warm up the configured tools."""
-        self._warm_up_tools()
+        """Create the asynchronous Hugging Face client."""
         if self._async_client is None:
             if self.api_type == HFGenerationAPIType.SERVERLESS_INFERENCE_API:
                 await _check_valid_model_async(self._model_or_url, HFModelType.GENERATION, self.token)

{huggingface_api_haystack-2.0.0 → huggingface_api_haystack-3.0.0}/src/haystack_integrations/components/rankers/huggingface_api/ranker.py

@@ -21,7 +21,7 @@ with LazyImport("Run 'pip install \"huggingface-api-haystack[grpc]\"' for grpc s
     from grpc_requests.aio import AsyncClient
 
 
-class TruncationDirection(str, Enum):
+class TruncationDirection(str, Enum):  # noqa: UP042 # StrEnum would change str() of this public enum
     """
     Defines the direction to truncate text when input length exceeds the model's limit.
 

{huggingface_api_haystack-2.0.0 → huggingface_api_haystack-3.0.0}/tests/test_chat_generator.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import os
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from typing import Any
 from unittest.mock import AsyncMock, MagicMock, Mock, patch
 
@@ -935,7 +935,7 @@ class TestSyncIntegration:
 
         response_meta = response["replies"][0].meta
         assert "completion_start_time" in response_meta
-        assert datetime.fromisoformat(response_meta["completion_start_time"]) <= datetime.now(timezone.utc)
+        assert datetime.fromisoformat(response_meta["completion_start_time"]) <= datetime.now(UTC)
         assert "usage" in response_meta
         assert "prompt_tokens" in response_meta["usage"]
         assert response_meta["usage"]["prompt_tokens"] >= 0
@@ -1334,115 +1334,6 @@ class TestTools:
         assert hf_tools[0].function.description == "useful to determine the weather in a given location"
         assert hf_tools[0].function.parameters == {"city": {"type": "string"}}
 
-    def test_warm_up_with_tools(self, mock_check_valid_model):
-        """Test that warm_up() calls warm_up on tools and is idempotent."""
-
-        # Create a mock tool that tracks if warm_up() was called
-        class MockTool(Tool):
-            warm_up_call_count = 0  # Class variable to track calls
-
-            def __init__(self):
-                super().__init__(
-                    name="mock_tool",
-                    description="A mock tool for testing",
-                    parameters={"x": {"type": "string"}},
-                    function=lambda x: x,
-                )
-
-            def warm_up(self):
-                MockTool.warm_up_call_count += 1
-
-        # Reset the class variable before test
-        MockTool.warm_up_call_count = 0
-        mock_tool = MockTool()
-
-        # Create HuggingFaceAPIChatGenerator with the mock tool
-        component = HuggingFaceAPIChatGenerator(
-            api_type=HFGenerationAPIType.SERVERLESS_INFERENCE_API,
-            api_params={"model": "HuggingFaceH4/zephyr-7b-alpha"},
-            tools=[mock_tool],
-        )
-
-        # Verify initial state - warm_up not called yet
-        assert MockTool.warm_up_call_count == 0
-        assert not component._tools_warmed_up
-
-        # Call warm_up() on the generator
-        component.warm_up()
-
-        # Assert that the tool's warm_up() was called
-        assert MockTool.warm_up_call_count == 1
-        assert component._tools_warmed_up
-
-        # Call warm_up() again and verify it's idempotent (only warms up once)
-        component.warm_up()
-
-        # The tool's warm_up should still only have been called once
-        assert MockTool.warm_up_call_count == 1
-        assert component._tools_warmed_up
-
-    def test_warm_up_with_no_tools(self, mock_check_valid_model):
-        """Test that warm_up() works when no tools are provided."""
-        component = HuggingFaceAPIChatGenerator(
-            api_type=HFGenerationAPIType.SERVERLESS_INFERENCE_API, api_params={"model": "HuggingFaceH4/zephyr-7b-alpha"}
-        )
-
-        # Verify initial state
-        assert not component._tools_warmed_up
-        assert component.tools is None
-
-        # Call warm_up() - should not raise an error
-        component.warm_up()
-
-        # Verify the component is warmed up
-        assert component._tools_warmed_up
-
-        # Call warm_up() again - should be idempotent
-        component.warm_up()
-        assert component._tools_warmed_up
-
-    def test_warm_up_with_multiple_tools(self, mock_check_valid_model):
-        """Test that warm_up() works with multiple tools."""
-        # Track warm_up calls
-        warm_up_calls = []
-
-        class MockTool(Tool):
-            def __init__(self, tool_name):
-                super().__init__(
-                    name=tool_name,
-                    description=f"Mock tool {tool_name}",
-                    parameters={"type": "object", "properties": {"x": {"type": "string"}}, "required": ["x"]},
-                    function=lambda x: f"{tool_name} result: {x}",
-                )
-
-            def warm_up(self):
-                warm_up_calls.append(self.name)
-
-        mock_tool1 = MockTool("tool1")
-        mock_tool2 = MockTool("tool2")
-
-        # Use a LIST of tools, not a Toolset
-        component = HuggingFaceAPIChatGenerator(
-            api_type=HFGenerationAPIType.SERVERLESS_INFERENCE_API,
-            api_params={"model": "HuggingFaceH4/zephyr-7b-alpha"},
-            tools=[mock_tool1, mock_tool2],
-        )
-
-        # Call warm_up()
-        component.warm_up()
-
-        # Assert that both tools' warm_up() were called
-        assert "tool1" in warm_up_calls
-        assert "tool2" in warm_up_calls
-        assert component._tools_warmed_up
-
-        # Track count
-        call_count = len(warm_up_calls)
-
-        # Verify idempotency
-        component.warm_up()
-        assert len(warm_up_calls) == call_count
-
 
 class TestReasoning:
     def test_run_with_reasoning_non_streaming(self, mock_check_valid_model, chat_messages):