transformers-haystack 0.3.0__tar.gz → 1.0.1__tar.gz

{transformers_haystack-0.3.0 → transformers_haystack-1.0.1}/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [integrations/transformers-v1.0.0] - 2026-09-10
+
+### 🐛 Bug Fixes
+
+- Fix (transformers): fix linting errors in transformers integration (#3867)
+
+### 🚜 Refactor
+
+- [**breaking**] Transformers - lifecycle refactor (#3939)
+
+
+## [integrations/transformers-v0.3.0] - 2026-08-24
+
+### 🐛 Bug Fixes
+
+- Fix new issues raised by ruff 0.16.0 (#3670)
+- Serialize missing init params in to_dict (transformers, huggingface_api, ragas) (#3808)
+
+### 🧹 Chores
+
+- Clarify how generation_kwargs passed in run are handled (#3805)
+
+
 ## [integrations/transformers-v0.2.0] - 2026-07-06
 
 ### 📚 Documentation

{transformers_haystack-0.3.0 → transformers_haystack-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: transformers-haystack
-Version: 0.3.0
+Version: 1.0.1
 Summary: Haystack integration for transformers
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/transformers#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
@@ -19,8 +19,8 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
-Requires-Dist: haystack-ai>=2.30.0
-Requires-Dist: transformers[sentencepiece,torch]>=4.57.0
+Requires-Dist: haystack-ai>=3.0.0
+Requires-Dist: transformers[sentencepiece,torch]>=5.0.0
 Description-Content-Type: text/markdown
 
 # transformers-haystack

{transformers_haystack-0.3.0 → transformers_haystack-1.0.1}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.30.0", "transformers[torch,sentencepiece]>=4.57.0"]
+dependencies = ["haystack-ai>=3.0.0", "transformers[torch,sentencepiece]>=5.0.0"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/transformers#readme"
@@ -81,8 +81,9 @@ disallow_incomplete_defs = true
 
 [[tool.mypy.overrides]]
 module = [
-  # these libraries do not ship type stubs
+  # accelerate does not ship type stubs
   "accelerate.*",
+  # tokenizers only ships a py.typed marker from 0.23.1 on; kept for older versions
   "tokenizers.*",
 ]
 ignore_missing_imports = true

{transformers_haystack-0.3.0 → transformers_haystack-1.0.1}/src/haystack_integrations/common/transformers/utils.py

@@ -3,7 +3,6 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import asyncio
-import copy
 import inspect
 from typing import Any
 
@@ -12,7 +11,6 @@ from haystack import logging
 from haystack.dataclasses import ComponentInfo, StreamingCallbackT, StreamingChunk, SyncStreamingCallbackT
 from haystack.utils.auth import Secret
 from haystack.utils.device import ComponentDevice
-from huggingface_hub import model_info
 
 from transformers import (
     PreTrainedTokenizer,
@@ -25,6 +23,21 @@ from transformers import (
 logger = logging.getLogger(__name__)
 
 
+def _with_hf_token(hf_kwargs: dict[str, Any], token: Secret | None) -> dict[str, Any]:
+    """
+    Return a copy of Hugging Face keyword arguments with a resolved token.
+
+    An explicitly provided `token` in `hf_kwargs` takes precedence over the `Secret`.
+
+    :param hf_kwargs: Keyword arguments passed to a Hugging Face API.
+    :param token: The token to resolve when `hf_kwargs` does not already contain one.
+    """
+    resolved_kwargs = hf_kwargs.copy()
+    if "token" not in resolved_kwargs:
+        resolved_kwargs["token"] = token.resolve_value() if token else None
+    return resolved_kwargs
+
+
 def _resolve_hf_device_map(device: ComponentDevice | None, model_kwargs: dict[str, Any] | None) -> dict[str, Any]:
     """
     Update `model_kwargs` to include the keyword argument `device_map`.
@@ -40,7 +53,7 @@ def _resolve_hf_device_map(device: ComponentDevice | None, model_kwargs: dict[st
     :param model_kwargs: Additional HF keyword arguments passed to `AutoModel.from_pretrained`.
         For details on what kwargs you can pass, see the model's documentation.
     """
-    model_kwargs = copy.copy(model_kwargs) or {}
+    model_kwargs = dict(model_kwargs or {})
     if model_kwargs.get("device_map"):
         if device is not None:
             logger.warning(
@@ -62,10 +75,8 @@ def _resolve_hf_device_map(device: ComponentDevice | None, model_kwargs: dict[st
 def _resolve_hf_pipeline_kwargs(
     huggingface_pipeline_kwargs: dict[str, Any],
     model: str,
-    task: str | None,
-    supported_tasks: list[str],
+    task: str,
     device: ComponentDevice | None,
-    token: Secret | None,
 ) -> dict[str, Any]:
     """
     Resolve the HuggingFace pipeline keyword arguments based on explicit user inputs.
@@ -74,30 +85,18 @@ def _resolve_hf_pipeline_kwargs(
         Hugging Face pipeline.
     :param model: The name or path of a Hugging Face model for on the HuggingFace Hub.
     :param task: The task for the Hugging Face pipeline.
-    :param supported_tasks: The list of supported tasks to check the task of the model against. If the task of the model
-        is not present within this list then a ValueError is thrown.
     :param device: The device on which the model is loaded. If `None`, the default device is automatically
         selected. If a device/device map is specified in `huggingface_pipeline_kwargs`, it overrides this parameter.
-    :param token: The token to use as HTTP bearer authorization for remote files.
-        If the token is also specified in the `huggingface_pipeline_kwargs`, this parameter will be ignored.
     """
-    resolved_token = token.resolve_value() if token else None
+    huggingface_pipeline_kwargs = huggingface_pipeline_kwargs.copy()
+
     # check if the huggingface_pipeline_kwargs contain the essential parameters
     # otherwise, populate them with values from other init parameters
     huggingface_pipeline_kwargs.setdefault("model", model)
-    huggingface_pipeline_kwargs.setdefault("token", resolved_token)
 
     resolved_device = ComponentDevice.resolve_device(device)
     resolved_device.update_hf_kwargs(huggingface_pipeline_kwargs, overwrite=False)
 
-    # task identification and validation
-    task = task or huggingface_pipeline_kwargs.get("task")
-    if task is None and isinstance(huggingface_pipeline_kwargs["model"], str):
-        task = model_info(huggingface_pipeline_kwargs["model"], token=huggingface_pipeline_kwargs["token"]).pipeline_tag
-
-    if task not in supported_tasks:
-        msg = f"Task '{task}' is not supported. The supported tasks are: {', '.join(supported_tasks)}."
-        raise ValueError(msg)
     huggingface_pipeline_kwargs["task"] = task
     return huggingface_pipeline_kwargs
 

{transformers_haystack-0.3.0 → transformers_haystack-1.0.1}/src/haystack_integrations/components/classifiers/transformers/zero_shot_document_classifier.py

@@ -9,7 +9,7 @@ from haystack import Document, 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
 
-from haystack_integrations.common.transformers.utils import _resolve_hf_pipeline_kwargs
+from haystack_integrations.common.transformers.utils import _resolve_hf_pipeline_kwargs, _with_hf_token
 from transformers import Pipeline as HfPipeline
 from transformers import pipeline
 
@@ -123,9 +123,7 @@ class TransformersZeroShotDocumentClassifier:
             huggingface_pipeline_kwargs=huggingface_pipeline_kwargs or {},
             model=model,
             task="zero-shot-classification",
-            supported_tasks=["zero-shot-classification"],
             device=device,
-            token=token,
         )
 
         self.huggingface_pipeline_kwargs = huggingface_pipeline_kwargs
@@ -143,8 +141,11 @@ class TransformersZeroShotDocumentClassifier:
         """
         Initializes the component.
         """
-        if self.pipeline is None:
-            self.pipeline = pipeline(**self.huggingface_pipeline_kwargs)
+        if self.pipeline is not None:
+            return
+
+        pipeline_kwargs = _with_hf_token(self.huggingface_pipeline_kwargs, self.token)
+        self.pipeline = pipeline(**pipeline_kwargs)
 
     def to_dict(self) -> dict[str, Any]:
         """
@@ -201,8 +202,8 @@ class TransformersZeroShotDocumentClassifier:
             - `documents`: A list of documents with an added metadata field called `classification`.
         """
 
-        if self.pipeline is None:
-            self.warm_up()
+        self.warm_up()
+        assert self.pipeline is not None  # noqa: S101
 
         if not isinstance(documents, list) or (documents and not isinstance(documents[0], Document)):
             msg = (
@@ -229,10 +230,7 @@ class TransformersZeroShotDocumentClassifier:
             for doc in documents
         ]
 
-        # mypy doesn't know this is set in warm_up
-        predictions = self.pipeline(  # type: ignore[misc]
-            texts, self.labels, multi_label=self.multi_label, batch_size=batch_size
-        )
+        predictions = self.pipeline(texts, self.labels, multi_label=self.multi_label, batch_size=batch_size)
 
         new_documents = []
         for prediction, document in zip(predictions, documents, strict=True):

{transformers_haystack-0.3.0 → transformers_haystack-1.0.1}/src/haystack_integrations/components/extractors/transformers/named_entity_extractor.py

@@ -10,9 +10,9 @@ from haystack.utils.auth import Secret
 from haystack.utils.device import ComponentDevice
 from haystack.utils.hf import deserialize_hf_model_kwargs, serialize_hf_model_kwargs
 
-from haystack_integrations.common.transformers.utils import _resolve_hf_pipeline_kwargs
-from transformers import AutoModelForTokenClassification, AutoTokenizer, pipeline
+from haystack_integrations.common.transformers.utils import _resolve_hf_pipeline_kwargs, _with_hf_token
 from transformers import Pipeline as HfPipeline
+from transformers import pipeline
 
 
 @dataclass
@@ -97,15 +97,10 @@ class TransformersNamedEntityExtractor:
             huggingface_pipeline_kwargs=pipeline_kwargs or {},
             model=model,
             task="ner",
-            supported_tasks=["ner"],
             device=self.device,
-            token=token,
         )
 
-        self.tokenizer: Any = None
-        self.model: AutoModelForTokenClassification | None = None
         self.pipeline: HfPipeline | None = None
-        self._warmed_up: bool = False
 
     def warm_up(self) -> None:
         """
@@ -114,24 +109,13 @@ class TransformersNamedEntityExtractor:
         :raises ComponentError:
             If the component fails to initialize successfully.
         """
-        if self._warmed_up:
+        if self.pipeline is not None:
             return
 
         try:
-            token = self.pipeline_kwargs.get("token", None)
-            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name_or_path, token=token)
-            self.model = AutoModelForTokenClassification.from_pretrained(self.model_name_or_path, token=token)
-
-            pipeline_params: dict[str, Any] = {
-                "task": "ner",
-                "model": self.model,
-                "tokenizer": self.tokenizer,
-                "aggregation_strategy": "simple",
-            }
-            pipeline_params.update({k: v for k, v in self.pipeline_kwargs.items() if k not in pipeline_params})
-            self.device.update_hf_kwargs(pipeline_params, overwrite=False)
-            self.pipeline = pipeline(**pipeline_params)
-            self._warmed_up = True
+            pipeline_kwargs = _with_hf_token(self.pipeline_kwargs, self.token)
+            pipeline_kwargs.setdefault("aggregation_strategy", "simple")
+            self.pipeline = pipeline(**pipeline_kwargs)
         except Exception as e:
             msg = f"{self.__class__.__name__} failed to initialize."
             raise ComponentError(msg) from e
@@ -150,8 +134,8 @@ class TransformersNamedEntityExtractor:
         :raises ComponentError:
             If the model fails to process a document.
         """
-        if not self._warmed_up:
-            self.warm_up()
+        self.warm_up()
+        assert self.pipeline is not None  # noqa: S101
 
         texts = [doc.content if doc.content is not None else "" for doc in documents]
         annotations = self._annotate(texts, batch_size=batch_size)
@@ -182,11 +166,10 @@ class TransformersNamedEntityExtractor:
         :returns:
             NER annotations.
         """
-        if not self.initialized:
+        if self.pipeline is None:
             msg = "NER model was not initialized - Did you call `warm_up()`?"
             raise ComponentError(msg)
 
-        assert self.pipeline is not None  # noqa: S101
         outputs = self.pipeline(texts, batch_size=batch_size)
         return [
             [
@@ -246,7 +229,7 @@ class TransformersNamedEntityExtractor:
         """
         Returns if the extractor is ready to annotate text.
         """
-        return (self.tokenizer is not None and self.model is not None) or self.pipeline is not None
+        return self.pipeline is not None
 
     @classmethod
     def get_stored_annotations(cls, document: Document) -> list[NamedEntityAnnotation] | None:

{transformers_haystack-0.3.0 → transformers_haystack-1.0.1}/src/haystack_integrations/components/generators/transformers/chat/chat_generator.py

@@ -28,20 +28,19 @@ from haystack.tools.utils import warm_up_tools
 from haystack.utils import ComponentDevice, Secret, deserialize_callable, serialize_callable
 from haystack.utils.hf import convert_message_to_hf_format, deserialize_hf_model_kwargs, serialize_hf_model_kwargs
 from huggingface_hub import model_info
-from packaging.version import Version
 
-import transformers
 from haystack_integrations.common.transformers.utils import (
     _AsyncHFTokenStreamingHandler,
     _HFTokenStreamingHandler,
     _StopWordsCriteria,
+    _with_hf_token,
 )
 from transformers import Pipeline as HfPipeline
 from transformers import PreTrainedTokenizer, PreTrainedTokenizerFast, StoppingCriteriaList, pipeline
 
 logger = logging.getLogger(__name__)
 
-PIPELINE_SUPPORTED_TASKS = ["text-generation", "text2text-generation", "image-text-to-text"]
+PIPELINE_SUPPORTED_TASKS = ["text-generation", "image-text-to-text"]
 
 DEFAULT_TOOL_PATTERN = (
     r"(?:<tool_call>)?"
@@ -119,7 +118,7 @@ class TransformersChatGenerator:
     def __init__(
         self,
         model: str = "Qwen/Qwen3-0.6B",
-        task: Literal["text-generation", "text2text-generation", "image-text-to-text"] | None = None,
+        task: Literal["text-generation", "image-text-to-text"] | None = None,
         device: ComponentDevice | None = None,
         token: Secret | None = Secret.from_env_var(["HF_API_TOKEN", "HF_TOKEN"], strict=False),
         chat_template: str | None = None,
@@ -143,8 +142,6 @@ class TransformersChatGenerator:
             If the model is specified in `huggingface_pipeline_kwargs`, this parameter is ignored.
         :param task: The task for the Hugging Face pipeline. Possible options:
             - `text-generation`: Supported by decoder models, like GPT.
-            - `text2text-generation`: Deprecated as of Transformers v5; use `text-generation` instead.
-              Previously supported by encoder-decoder models such as T5.
             - `image-text-to-text`: Supported by vision-language models.
             If the task is specified in `huggingface_pipeline_kwargs`, this parameter is ignored.
             If not specified, the component calls the Hugging Face API to infer the task from the model name.
@@ -192,32 +189,17 @@ class TransformersChatGenerator:
         generation_kwargs = generation_kwargs or {}
 
         self.token = token
-        token = token.resolve_value() if token else None
 
         # check if the huggingface_pipeline_kwargs contain the essential parameters
         # otherwise, populate them with values from other init parameters
         huggingface_pipeline_kwargs.setdefault("model", model)
-        huggingface_pipeline_kwargs.setdefault("token", token)
 
         device = ComponentDevice.resolve_device(device)
         device.update_hf_kwargs(huggingface_pipeline_kwargs, overwrite=False)
 
-        # task identification and validation
-        if task is None:
-            if "task" in huggingface_pipeline_kwargs:
-                task = huggingface_pipeline_kwargs["task"]
-            elif isinstance(huggingface_pipeline_kwargs["model"], str):
-                task = model_info(
-                    huggingface_pipeline_kwargs["model"], token=huggingface_pipeline_kwargs["token"]
-                ).pipeline_tag  # type: ignore[assignment]  # we'll check below if task is in supported tasks
-
-        if task not in PIPELINE_SUPPORTED_TASKS:
-            msg = f"Task '{task}' is not supported. The supported tasks are: {', '.join(PIPELINE_SUPPORTED_TASKS)}."
-            raise ValueError(msg)
-        if task == "text2text-generation" and Version(transformers.__version__) >= Version("5.0.0"):
-            msg = "Task 'text2text-generation' is not supported with transformers v5 or higher."
-            raise ValueError(msg)
-        huggingface_pipeline_kwargs["task"] = task
+        task = task or huggingface_pipeline_kwargs.get("task")
+        if task is not None:
+            huggingface_pipeline_kwargs["task"] = task
 
         # if not specified, set return_full_text to False for text-generation
         # only generated text is returned (excluding prompt)
@@ -244,26 +226,7 @@ class TransformersChatGenerator:
         self.enable_thinking = enable_thinking
 
         self._owns_executor = async_executor is None
-        self.executor = (
-            ThreadPoolExecutor(thread_name_prefix=f"async-TransformersChatGenerator-executor-{id(self)}", max_workers=1)
-            if async_executor is None
-            else async_executor
-        )
-        self._is_warmed_up = False
-
-    def __del__(self) -> None:
-        """
-        Cleanup when the instance is being destroyed.
-        """
-        if hasattr(self, "_owns_executor") and self._owns_executor and hasattr(self, "executor"):
-            self.executor.shutdown(wait=True)
-
-    def shutdown(self) -> None:
-        """
-        Explicitly shutdown the executor if we own it.
-        """
-        if self._owns_executor:
-            self.executor.shutdown(wait=True)
+        self.executor = async_executor
 
     def _get_telemetry_data(self) -> dict[str, Any]:
         """
@@ -277,18 +240,34 @@ class TransformersChatGenerator:
         """
         Initializes the component and warms up tools if provided.
         """
-        if self._is_warmed_up:
-            return
-
-        # Initialize the pipeline
         if self.pipeline is None:
-            self.pipeline = pipeline(**self.huggingface_pipeline_kwargs)
-
-        # Warm up tools
-        if self.tools:
-            warm_up_tools(self.tools)
+            pipeline_kwargs = _with_hf_token(self.huggingface_pipeline_kwargs, self.token)
+            task = pipeline_kwargs.get("task")
+            if task is None and isinstance(pipeline_kwargs["model"], str):
+                task = model_info(pipeline_kwargs["model"], token=pipeline_kwargs["token"]).pipeline_tag
+
+            if task not in PIPELINE_SUPPORTED_TASKS:
+                msg = f"Task '{task}' is not supported. The supported tasks are: {', '.join(PIPELINE_SUPPORTED_TASKS)}."
+                raise ValueError(msg)
+            pipeline_kwargs["task"] = task
+
+            hf_pipeline = pipeline(**pipeline_kwargs)
+            if self.tools:
+                warm_up_tools(self.tools)
+            self.pipeline = hf_pipeline
+
+        if self._owns_executor and self.executor is None:
+            self.executor = ThreadPoolExecutor(
+                thread_name_prefix=f"async-TransformersChatGenerator-executor-{id(self)}", max_workers=1
+            )
 
-        self._is_warmed_up = True
+    def close(self) -> None:
+        """
+        Close the executor owned by the component.
+        """
+        if self._owns_executor and self.executor is not None:
+            self.executor.shutdown(wait=True)
+            self.executor = None
 
     def to_dict(self) -> dict[str, Any]:
         """
@@ -362,8 +341,8 @@ class TransformersChatGenerator:
         :returns: A dictionary with the following keys:
             - `replies`: A list containing the generated responses as ChatMessage instances.
         """
-        if self.pipeline is None:
-            self.warm_up()
+        self.warm_up()
+        assert self.pipeline is not None  # noqa: S101
 
         messages = _normalize_messages(messages)
 
@@ -383,8 +362,6 @@ class TransformersChatGenerator:
                 component_info=ComponentInfo.from_component(self),
             )
 
-        # We know it's not None because we check it in _prepare_inputs
-        assert self.pipeline is not None  # noqa: S101
         # Generate responses
         output = self.pipeline(prepared_inputs["prepared_prompt"], **prepared_inputs["generation_kwargs"])
 
@@ -483,8 +460,9 @@ class TransformersChatGenerator:
         :returns: A dictionary with the following keys:
             - `replies`: A list containing the generated responses as ChatMessage instances.
         """
-        if self.pipeline is None:
-            self.warm_up()
+        self.warm_up()
+        assert self.pipeline is not None  # noqa: S101
+        assert self.executor is not None  # noqa: S101
 
         messages = _normalize_messages(messages)
 
@@ -559,6 +537,8 @@ class TransformersChatGenerator:
         :returns: A dictionary containing the prepared prompt, tokenizer, generation kwargs, and tools.
         :raises ValueError: If both tools and streaming_callback are provided.
         """
+        assert self.pipeline is not None  # noqa: S101
+
         tools = tools or self.tools
         if tools and streaming_callback is not None:
             msg = "Using tools and streaming at the same time is not supported. Please choose one."
@@ -566,11 +546,12 @@ class TransformersChatGenerator:
         flat_tools = flatten_tools_or_toolsets(tools)
         _check_duplicate_tool_names(flat_tools)
 
-        # mypy doesn't know this is set in warm_up
-        tokenizer = self.pipeline.tokenizer  # type: ignore[union-attr]
+        tokenizer = self.pipeline.tokenizer
 
         # Check and update generation parameters
         generation_kwargs = {**self.generation_kwargs, **(generation_kwargs or {})}
+        if self.pipeline.task == "text-generation":
+            generation_kwargs.setdefault("return_full_text", False)
 
         # If streaming_callback is provided, ensure that num_return_sequences is set to 1
         if streaming_callback:
@@ -592,7 +573,7 @@ class TransformersChatGenerator:
             _StopWordsCriteria(
                 tokenizer,  # type: ignore[arg-type]
                 stop_words,
-                self.pipeline.device,  # type: ignore[union-attr]
+                self.pipeline.device,
             )
             if stop_words
             else None

{transformers_haystack-0.3.0 → transformers_haystack-1.0.1}/src/haystack_integrations/components/readers/transformers/extractive_reader.py

@@ -150,6 +150,7 @@ class TransformersExtractiveReader:
             answers_per_seq=self.answers_per_seq,
             no_answer=self.no_answer,
             calibration_factor=self.calibration_factor,
+            overlap_threshold=self.overlap_threshold,
             model_kwargs=self.model_kwargs,
         )
 
@@ -176,21 +177,23 @@ class TransformersExtractiveReader:
         """
         Initializes the component.
         """
+        if self.model is not None:
+            return
+
         # Take the first device used by `accelerate`. Needed to pass inputs from the tokenizer to the correct device.
-        if self.model is None:
-            self.model = AutoModelForQuestionAnswering.from_pretrained(
-                self.model_name_or_path, token=self.token.resolve_value() if self.token else None, **self.model_kwargs
-            )
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                self.model_name_or_path, token=self.token.resolve_value() if self.token else None
-            )
-            assert self.model is not None  # noqa: S101 # mypy doesn't know this is set in the line above
-            # hf_device_map appears to only be set now when mixed devices are actually used.
-            # So if it's missing then we can use the device attribute which is set even for single-device models.
-            if hf_device_map := getattr(self.model, "hf_device_map", None):
-                self.device = ComponentDevice.from_multiple(device_map=DeviceMap.from_hf(hf_device_map))
-            else:
-                self.device = ComponentDevice.from_single(Device.from_str(str(self.model.device)))
+        token = self.token.resolve_value() if self.token else None
+        model = AutoModelForQuestionAnswering.from_pretrained(self.model_name_or_path, token=token, **self.model_kwargs)
+        tokenizer = AutoTokenizer.from_pretrained(self.model_name_or_path, token=token)
+        # hf_device_map appears to only be set now when mixed devices are actually used.
+        # So if it's missing then we can use the device attribute which is set even for single-device models.
+        if hf_device_map := getattr(model, "hf_device_map", None):
+            device = ComponentDevice.from_multiple(device_map=DeviceMap.from_hf(hf_device_map))
+        else:
+            device = ComponentDevice.from_single(Device.from_str(str(model.device)))
+
+        self.model = model
+        self.tokenizer = tokenizer
+        self.device = device
 
     @staticmethod
     def _flatten_documents(
@@ -314,8 +317,10 @@ class TransformersExtractiveReader:
                 # But we shouldn't have special tokens in the answers at this point
                 # The whole span is given by the start of the start_token (index 0)
                 # and the end of the end token (index 1)
-                s_char_spans.append(encoding.token_to_chars(start_token)[0])
-                e_char_spans.append(encoding.token_to_chars(end_token)[1])
+                # `type: ignore[index]` because tokenizers>=0.23.1 types the return as
+                # `tuple[int, int] | None`; the `None` case cannot occur here per the above
+                s_char_spans.append(encoding.token_to_chars(start_token)[0])  # type: ignore[index]
+                e_char_spans.append(encoding.token_to_chars(end_token)[1])  # type: ignore[index]
             start_candidates_tokens_to_chars.append(s_char_spans)
             end_candidates_tokens_to_chars.append(e_char_spans)
             valid_candidates_values.append(candidates_values[i][valid])
@@ -581,8 +586,10 @@ class TransformersExtractiveReader:
         :returns:
             List of answers sorted by (desc.) answer score.
         """
-        if self.model is None:
-            self.warm_up()
+        self.warm_up()
+        assert self.model is not None  # noqa: S101
+        assert self.tokenizer is not None  # noqa: S101
+        assert self.device is not None  # noqa: S101
 
         if not documents:
             return {"answers": []}

{transformers_haystack-0.3.0 → transformers_haystack-1.0.1}/src/haystack_integrations/components/routers/transformers/text_router.py

@@ -8,7 +8,7 @@ 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
 
-from haystack_integrations.common.transformers.utils import _resolve_hf_pipeline_kwargs
+from haystack_integrations.common.transformers.utils import _resolve_hf_pipeline_kwargs, _with_hf_token
 from transformers import AutoConfig, Pipeline, pipeline
 
 
@@ -92,16 +92,13 @@ class TransformersTextRouter:
             huggingface_pipeline_kwargs=huggingface_pipeline_kwargs or {},
             model=model,
             task="text-classification",
-            supported_tasks=["text-classification"],
             device=device,
-            token=token,
         )
         self.huggingface_pipeline_kwargs = huggingface_pipeline_kwargs
 
         if labels is None:
-            config = AutoConfig.from_pretrained(
-                huggingface_pipeline_kwargs["model"], token=huggingface_pipeline_kwargs["token"]
-            )
+            pipeline_kwargs = _with_hf_token(huggingface_pipeline_kwargs, token)
+            config = AutoConfig.from_pretrained(pipeline_kwargs["model"], token=pipeline_kwargs["token"])
             self.labels = list(config.label2id.keys())
         else:
             self.labels = labels
@@ -121,11 +118,14 @@ class TransformersTextRouter:
         """
         Initializes the component.
         """
-        if self.pipeline is None:
-            self.pipeline = pipeline(**self.huggingface_pipeline_kwargs)
+        if self.pipeline is not None:
+            return
+
+        pipeline_kwargs = _with_hf_token(self.huggingface_pipeline_kwargs, self.token)
+        hf_pipeline = pipeline(**pipeline_kwargs)
 
         # Verify labels from the model configuration file match provided labels
-        label2id = self.pipeline.model.config.label2id
+        label2id = hf_pipeline.model.config.label2id
         if label2id is not None:
             labels = set(label2id.keys())
             if set(self.labels) != labels:
@@ -134,6 +134,7 @@ class TransformersTextRouter:
                     f"Provided labels: {self.labels}. Model labels: {labels}"
                 )
                 raise ValueError(msg)
+        self.pipeline = hf_pipeline
 
     def to_dict(self) -> dict[str, Any]:
         """
@@ -181,16 +182,13 @@ class TransformersTextRouter:
         :raises TypeError:
             If the input is not a str.
         """
-        if self.pipeline is None:
-            self.warm_up()
+        self.warm_up()
+        assert self.pipeline is not None  # noqa: S101
 
         if not isinstance(text, str):
             msg = "TransformersTextRouter expects a str as input."
             raise TypeError(msg)
 
-        # mypy doesn't know this is set in warm_up
-        prediction = self.pipeline(  # type: ignore[misc]
-            [text], return_all_scores=False, function_to_apply="none"
-        )
+        prediction = self.pipeline([text], return_all_scores=False, function_to_apply="none")
         label = prediction[0]["label"]
         return {label: text}