transformers 5.0.0rc2__py3-none-any.whl → 5.0.0rc3__py3-none-any.whl

transformers/configuration_utils.py

@@ -18,8 +18,7 @@ import copy
 import json
 import math
 import os
-import warnings
-from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, TypeVar, Union
 
 from huggingface_hub import create_repo
 from packaging import version
@@ -184,10 +183,10 @@ class PreTrainedConfig(PushToHubMixin, RotaryEmbeddingConfigMixin):
     sub_configs: dict[str, type["PreTrainedConfig"]] = {}
     has_no_defaults_at_init: bool = False
     attribute_map: dict[str, str] = {}
-    base_model_tp_plan: Optional[dict[str, Any]] = None
-    base_model_pp_plan: Optional[dict[str, tuple[list[str]]]] = None
-    base_model_ep_plan: Optional[dict[str, tuple[list[str]]]] = None
-    _auto_class: Optional[str] = None
+    base_model_tp_plan: dict[str, Any] | None = None
+    base_model_pp_plan: dict[str, tuple[list[str]]] | None = None
+    base_model_ep_plan: dict[str, tuple[list[str]]] | None = None
+    _auto_class: str | None = None
 
     def __setattr__(self, key, value):
         if key in super().__getattribute__("attribute_map"):
@@ -206,30 +205,30 @@ class PreTrainedConfig(PushToHubMixin, RotaryEmbeddingConfigMixin):
         output_hidden_states: bool = False,
         output_attentions: bool = False,
         return_dict: bool = True,
-        dtype: Optional[Union[str, "torch.dtype"]] = None,
+        dtype: Union[str, "torch.dtype"] | None = None,
         # Common arguments
         tie_word_embeddings: bool = True,
         chunk_size_feed_forward: int = 0,
         is_encoder_decoder: bool = False,
         is_decoder: bool = False,
-        cross_attention_hidden_size: Optional[int] = None,
+        cross_attention_hidden_size: int | None = None,
         add_cross_attention: bool = False,
         # Fine-tuning task arguments
-        architectures: Optional[list[str]] = None,
-        finetuning_task: Optional[str] = None,
-        id2label: Optional[dict[int, str]] = None,
-        label2id: Optional[dict[str, int]] = None,
-        num_labels: Optional[int] = None,
-        task_specific_params: Optional[dict[str, Any]] = None,
-        problem_type: Optional[str] = None,
+        architectures: list[str] | None = None,
+        finetuning_task: str | None = None,
+        id2label: dict[int, str] | None = None,
+        label2id: dict[str, int] | None = None,
+        num_labels: int | None = None,
+        task_specific_params: dict[str, Any] | None = None,
+        problem_type: str | None = None,
         # Tokenizer kwargs
-        tokenizer_class: Optional[str] = None,
-        prefix: Optional[str] = None,
-        bos_token_id: Optional[int] = None,
-        pad_token_id: Optional[int] = None,
-        eos_token_id: Optional[int] = None,
-        sep_token_id: Optional[int] = None,
-        decoder_start_token_id: Optional[int] = None,
+        tokenizer_class: str | None = None,
+        prefix: str | None = None,
+        bos_token_id: int | None = None,
+        pad_token_id: int | None = None,
+        eos_token_id: int | None = None,
+        sep_token_id: int | None = None,
+        decoder_start_token_id: int | None = None,
         **kwargs,
     ):
         # Validation for some arguments
@@ -330,14 +329,6 @@ class PreTrainedConfig(PushToHubMixin, RotaryEmbeddingConfigMixin):
         # Drop the transformers version info
         self.transformers_version = kwargs.pop("transformers_version", None)
 
-        # Deal with gradient checkpointing
-        if kwargs.get("gradient_checkpointing", False):
-            warnings.warn(
-                "Passing `gradient_checkpointing` to a config initialization is deprecated and will be removed in v5 "
-                "Transformers. Using `model.gradient_checkpointing_enable()` instead, or if you are using the "
-                "`Trainer` API, pass `gradient_checkpointing=True` in your `TrainingArguments`."
-            )
-
         # Additional attributes without default values
         for key, value in kwargs.items():
             try:
@@ -351,7 +342,7 @@ class PreTrainedConfig(PushToHubMixin, RotaryEmbeddingConfigMixin):
         self.label2id = dict(zip(self.id2label.values(), self.id2label.keys()))
 
     @property
-    def name_or_path(self) -> Optional[str]:
+    def name_or_path(self) -> str | None:
         return getattr(self, "_name_or_path", None)
 
     @name_or_path.setter
@@ -1100,6 +1091,9 @@ class PreTrainedConfig(PushToHubMixin, RotaryEmbeddingConfigMixin):
         Checks and removes if there are any keys in the dict that should not be serialized when saving the config.
         Runs recursive check on the dict, to remove from all sub configs.
         """
+
+        if "_is_quantized" in d:
+            del d["_is_quantized"]
         if "_auto_class" in d:
             del d["_auto_class"]
         if "_output_attentions" in d:
@@ -1144,11 +1138,15 @@ class PreTrainedConfig(PushToHubMixin, RotaryEmbeddingConfigMixin):
 
     def _get_generation_parameters(self) -> dict[str, Any]:
         """
-        Gets the non-default generation parameters on the PreTrainedConfig instance
+        Checks if there are generation parameters in `PreTrainedConfig` instance. Note that
+        we should not save generation params in PreTrainedConfig, and we will raise error
+        if there are any.
         """
         generation_params = {}
         default_config = self.__class__().to_dict() if not self.has_no_defaults_at_init else {}
         for key in GenerationConfig._get_default_generation_params().keys():
+            if key == "use_cache":
+                continue  # common key for most models
             if hasattr(self, key) and getattr(self, key) is not None and key not in default_config:
                 generation_params[key] = getattr(self, key)
 
@@ -1306,7 +1304,7 @@ ALLOWED_MLP_LAYER_TYPES = (
 )
 
 
-def layer_type_validation(layer_types: list[str], num_hidden_layers: Optional[int] = None, attention: bool = True):
+def layer_type_validation(layer_types: list[str], num_hidden_layers: int | None = None, attention: bool = True):
     """Check that `layer_types` is correctly defined."""
     allowed_layer_types = ALLOWED_ATTENTION_LAYER_TYPES if attention else ALLOWED_MLP_LAYER_TYPES
     if not all(layer_type in allowed_layer_types for layer_type in layer_types):

transformers/conversion_mapping.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright (C) 2025 the HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -229,6 +228,7 @@ def _build_checkpoint_conversion_mapping():
         WeightRenaming("mlp.moe_statics.e_score_correction_bias", "mlp.gate.moe_statics.e_score_correction_bias")
     ]
     mapping["glm4_moe"] = mapping["qwen2_moe"].copy()
+    mapping["glm4_moe_lite"] = mapping["qwen2_moe"].copy()
     mapping["glm4v_moe"] = mapping["qwen2_moe"].copy()
     mapping["longcat_flash"] = mapping["qwen2_moe"].copy()
     mapping["qwen3_moe"] = mapping["qwen2_moe"].copy()
@@ -237,6 +237,10 @@ def _build_checkpoint_conversion_mapping():
     mapping["qwen3_vl_moe"] = mapping["qwen2_moe"].copy()
     mapping["hunyuan_v1_moe"] = mapping["qwen2_moe"].copy()
     mapping["minimax"] = mapping["mixtral"].copy()
+    mapping["minimax_m2"] = mapping["mixtral"].copy()
+    mapping["minimax_m2"] += [
+        WeightRenaming(".block_sparse_moe.e_score_correction_bias", ".mlp.e_score_correction_bias"),
+    ]
     mapping["flex_olmo"] = mapping["qwen2_moe"].copy()
     mapping["olmoe"] = mapping["qwen2_moe"].copy()
 

transformers/convert_slow_tokenizer.py

@@ -21,7 +21,6 @@ allow to make our dependency on SentencePiece optional.
 import warnings
 from collections.abc import Collection
 from functools import lru_cache
-from typing import Optional
 
 from packaging import version
 from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
@@ -120,7 +119,7 @@ def _get_prepend_scheme(add_prefix_space: bool, original_tokenizer) -> str:
     return prepend_scheme
 
 
-def generate_merges(vocab, vocab_scores, skip_tokens: Optional[Collection[str]] = None):
+def generate_merges(vocab, vocab_scores, skip_tokens: Collection[str] | None = None):
     skip_tokens = set(skip_tokens) if skip_tokens is not None else set()
     reverse = vocab_scores is not None
     vocab_scores = dict(vocab_scores) if reverse else vocab
@@ -420,9 +419,7 @@ class OpenAIGPTConverter(Converter):
 
 
 class GPT2Converter(Converter):
-    def converted(
-        self, vocab: Optional[dict[str, int]] = None, merges: Optional[list[tuple[str, str]]] = None
-    ) -> Tokenizer:
+    def converted(self, vocab: dict[str, int] | None = None, merges: list[tuple[str, str]] | None = None) -> Tokenizer:
         if not vocab:
             vocab = self.original_tokenizer.encoder
         if not merges:
@@ -491,9 +488,7 @@ class HerbertConverter(Converter):
 
 
 class Qwen2Converter(Converter):
-    def converted(
-        self, vocab: Optional[dict[str, int]] = None, merges: Optional[list[tuple[str, str]]] = None
-    ) -> Tokenizer:
+    def converted(self, vocab: dict[str, int] | None = None, merges: list[tuple[str, str]] | None = None) -> Tokenizer:
         if not vocab:
             vocab = self.original_tokenizer.encoder
         if not merges:

transformers/core_model_loading.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright 2025 The HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -27,7 +26,7 @@ from contextlib import contextmanager
 from copy import deepcopy
 from dataclasses import dataclass, field
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 import torch
 
@@ -51,7 +50,7 @@ logger = logging.get_logger(__name__)
 
 
 def build_glob_alternation(
-    globs: list[Union[WeightRenaming, WeightConverter, str]],
+    globs: list[WeightRenaming | WeightConverter | str],
 ) -> tuple[re.Pattern, dict[str, str], dict[str, str]]:
     """
     Build a single alternation regex with one named group per glob.
@@ -146,7 +145,7 @@ class Concatenate(ConversionOps):
     ) -> dict[str, torch.Tensor]:
         target_pattern = self.get_target_pattern(target_patterns)
         all_tensors = []
-        # Very important to keep the relative order of the source patterms here, so we iterate over them not the
+        # Very important to keep the relative order of the source patterns here, so we iterate over them not the
         # input directly as it's unordered!
         for source_pattern in source_patterns:
             tensors = input_dict[source_pattern]
@@ -442,12 +441,12 @@ class Transpose(ConversionOps):
 
 @dataclass(slots=True)
 class WeightTransform:
-    source_patterns: Union[str, list[str]] = field(init=True)
-    target_patterns: Union[str, list[str]] = field(init=True)
+    source_patterns: str | list[str] = field(init=True)
+    target_patterns: str | list[str] = field(init=True)
     compiled_sources: re.Pattern = field(init=False)
 
-    distributed_operation: Optional[TensorParallelLayer] = None
-    quantization_operation: Optional[ConversionOps] = None
+    distributed_operation: TensorParallelLayer | None = None
+    quantization_operation: ConversionOps | None = None
 
     collected_tensors: dict[str, list[Future]] = field(default_factory=lambda: defaultdict(list), init=False)
     layer_targets: dict[str, set[str]] = field(default_factory=lambda: defaultdict(set), init=False)
@@ -573,8 +572,8 @@ class WeightRenaming(WeightTransform):
         model=None,
         config=None,
         hf_quantizer=None,
-        missing_keys: Optional[MutableSet[str]] = None,
-        conversion_errors: Optional[MutableMapping[str, str]] = None,
+        missing_keys: MutableSet[str] | None = None,
+        conversion_errors: MutableMapping[str, str] | None = None,
     ):
         # Collect the tensors here - we use a new dictionary to avoid keeping them in memory in the internal
         # attribute during the whole process
@@ -630,8 +629,8 @@ class WeightConverter(WeightTransform):
         model=None,
         config=None,
         hf_quantizer=None,
-        missing_keys: Optional[MutableSet[str]] = None,
-        conversion_errors: Optional[MutableMapping[str, str]] = None,
+        missing_keys: MutableSet[str] | None = None,
+        conversion_errors: MutableMapping[str, str] | None = None,
     ):
         # Collect the tensors here - we use a new dictionary to avoid keeping them in memory in the internal
         # attribute during the whole process
@@ -742,7 +741,7 @@ def log_conversion_errors(
     first_target_key: str,
     conversion_errors: MutableMapping[str, str],
     extras: Any = None,
-    op: Union[list[ConversionOps], ConversionOps, None] = None,
+    op: list[ConversionOps] | ConversionOps | None = None,
 ):
     """Catch all exceptions during `convert` calls, and log the errors for later. Re-raise a `SkipParameters` exception
     that will be catched later to skip the parameters that raised the original Exception."""
@@ -750,7 +749,7 @@ def log_conversion_errors(
         yield
     except Exception as e:
 
-        def _format_op_name(curr_op: Union[list[ConversionOps], ConversionOps, None]) -> Optional[str]:
+        def _format_op_name(curr_op: list[ConversionOps] | ConversionOps | None) -> str | None:
             if curr_op is None:
                 return None
             if isinstance(curr_op, (list, tuple, set)):
@@ -786,7 +785,7 @@ def set_param_for_module(
     mismatch_keys: MutableSet[tuple[str, torch.Size, torch.Size]],
     missing_keys: MutableSet[str],
     unexpected_keys: MutableSet[str],
-    distributed_operation: Optional[TensorParallelLayer],
+    distributed_operation: TensorParallelLayer | None,
     hf_quantizer: HfQuantizer,
 ):
     module_path, _, param_name = target_name.rpartition(".")

transformers/data/processors/glue.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
 # Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
 #

transformers/data/processors/utils.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
 # Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
 #

transformers/data/processors/xnli.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
 # Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
 #

transformers/dependency_versions_table.py

@@ -1,6 +1,6 @@
 # THIS FILE HAS BEEN AUTOGENERATED. To update:
 # 1. modify the `_deps` dict in setup.py
-# 2. run `make deps_table_update``
+# 2. run `make fix-repo``
 deps = {
     "Pillow": "Pillow>=10.0.1,<=15.0",
     "accelerate": "accelerate>=1.1.0",
@@ -22,7 +22,7 @@ deps = {
     "GitPython": "GitPython<3.1.19",
     "hf-doc-builder": "hf-doc-builder>=0.3.0",
     "hf_xet": "hf_xet",
-    "huggingface-hub": "huggingface-hub>=1.2.1,<2.0",
+    "huggingface-hub": "huggingface-hub>=1.3.0,<2.0",
     "importlib_metadata": "importlib_metadata",
     "ipadic": "ipadic>=1.0.0,<2.0",
     "jinja2": "jinja2>=3.1.0",
@@ -60,7 +60,7 @@ deps = {
     "rhoknp": "rhoknp>=1.1.0,<1.3.1",
     "rjieba": "rjieba",
     "rouge-score": "rouge-score!=0.0.7,!=0.0.8,!=0.1,!=0.1.1",
-    "ruff": "ruff==0.13.1",
+    "ruff": "ruff==0.14.10",
     "sacrebleu": "sacrebleu>=1.4.12,<2.0.0",
     "sacremoses": "sacremoses",
     "safetensors": "safetensors>=0.4.3",
@@ -91,5 +91,5 @@ deps = {
     "libcst": "libcst",
     "rich": "rich",
     "opentelemetry-api": "opentelemetry-api",
-    "mistral-common[opencv]": "mistral-common[opencv]>=1.6.3",
+    "mistral-common[image]": "mistral-common[image]>=1.8.8",
 }

transformers/distributed/configuration_utils.py

@@ -75,8 +75,7 @@ class DistributedConfig:
     # Copied from transformers.utils.quantization_config.QuantizationConfigMixin.__iter__
     def __iter__(self):
         """allows `dict(obj)` for situations where obj may be a dict or QuantizationConfigMixin"""
-        for attr, value in copy.deepcopy(self.__dict__).items():
-            yield attr, value
+        yield from copy.deepcopy(self.__dict__).items()
 
     # Copied from transformers.utils.quantization_config.QuantizationConfigMixin.__repr__
     def __repr__(self):

transformers/dynamic_module_utils.py

@@ -28,7 +28,7 @@ import sys
 import threading
 from pathlib import Path
 from types import ModuleType
-from typing import Any, Optional, Union
+from typing import Any
 
 from huggingface_hub import is_offline_mode, try_to_load_from_cache
 from packaging import version
@@ -98,7 +98,7 @@ def init_hf_modules():
         importlib.invalidate_caches()
 
 
-def create_dynamic_module(name: Union[str, os.PathLike]) -> None:
+def create_dynamic_module(name: str | os.PathLike) -> None:
     """
     Creates a dynamic module in the cache directory for modules.
 
@@ -120,7 +120,7 @@ def create_dynamic_module(name: Union[str, os.PathLike]) -> None:
         importlib.invalidate_caches()
 
 
-def get_relative_imports(module_file: Union[str, os.PathLike]) -> list[str]:
+def get_relative_imports(module_file: str | os.PathLike) -> list[str]:
     """
     Get the list of modules that are relatively imported in a module file.
 
@@ -141,7 +141,7 @@ def get_relative_imports(module_file: Union[str, os.PathLike]) -> list[str]:
     return list(set(relative_imports))
 
 
-def get_relative_import_files(module_file: Union[str, os.PathLike]) -> list[str]:
+def get_relative_import_files(module_file: str | os.PathLike) -> list[str]:
     """
     Get the list of all files that are needed for a given module. Note that this function recurses through the relative
     imports (if a imports b and b imports c, it will return module files for b and c).
@@ -173,7 +173,7 @@ def get_relative_import_files(module_file: Union[str, os.PathLike]) -> list[str]
     return all_relative_imports
 
 
-def get_imports(filename: Union[str, os.PathLike]) -> list[str]:
+def get_imports(filename: str | os.PathLike) -> list[str]:
     """
     Extracts all the libraries (not relative imports this time) that are imported in a file.
 
@@ -228,7 +228,7 @@ def get_imports(filename: Union[str, os.PathLike]) -> list[str]:
     return sorted(imported_modules)
 
 
-def check_imports(filename: Union[str, os.PathLike]) -> list[str]:
+def check_imports(filename: str | os.PathLike) -> list[str]:
     """
     Check if the current Python environment contains all the libraries that are imported in a file. Will raise if a
     library is missing.
@@ -265,7 +265,7 @@ def check_imports(filename: Union[str, os.PathLike]) -> list[str]:
 
 def get_class_in_module(
     class_name: str,
-    module_path: Union[str, os.PathLike],
+    module_path: str | os.PathLike,
     *,
     force_reload: bool = False,
 ) -> type:
@@ -290,7 +290,7 @@ def get_class_in_module(
         if force_reload:
             sys.modules.pop(name, None)
             importlib.invalidate_caches()
-        cached_module: Optional[ModuleType] = sys.modules.get(name)
+        cached_module: ModuleType | None = sys.modules.get(name)
         module_spec = importlib.util.spec_from_file_location(name, location=module_file)
 
         # Hash the module file and all its relative imports to check if we need to reload it
@@ -312,16 +312,16 @@ def get_class_in_module(
 
 
 def get_cached_module_file(
-    pretrained_model_name_or_path: Union[str, os.PathLike],
+    pretrained_model_name_or_path: str | os.PathLike,
     module_file: str,
-    cache_dir: Optional[Union[str, os.PathLike]] = None,
+    cache_dir: str | os.PathLike | None = None,
     force_download: bool = False,
-    proxies: Optional[dict[str, str]] = None,
-    token: Optional[Union[bool, str]] = None,
-    revision: Optional[str] = None,
+    proxies: dict[str, str] | None = None,
+    token: bool | str | None = None,
+    revision: str | None = None,
     local_files_only: bool = False,
-    repo_type: Optional[str] = None,
-    _commit_hash: Optional[str] = None,
+    repo_type: str | None = None,
+    _commit_hash: str | None = None,
     **deprecated_kwargs,
 ) -> str:
     """
@@ -475,15 +475,15 @@ def get_cached_module_file(
 
 def get_class_from_dynamic_module(
     class_reference: str,
-    pretrained_model_name_or_path: Union[str, os.PathLike],
-    cache_dir: Optional[Union[str, os.PathLike]] = None,
+    pretrained_model_name_or_path: str | os.PathLike,
+    cache_dir: str | os.PathLike | None = None,
     force_download: bool = False,
-    proxies: Optional[dict[str, str]] = None,
-    token: Optional[Union[bool, str]] = None,
-    revision: Optional[str] = None,
+    proxies: dict[str, str] | None = None,
+    token: bool | str | None = None,
+    revision: str | None = None,
     local_files_only: bool = False,
-    repo_type: Optional[str] = None,
-    code_revision: Optional[str] = None,
+    repo_type: str | None = None,
+    code_revision: str | None = None,
     **kwargs,
 ) -> type:
     """
@@ -583,7 +583,7 @@ def get_class_from_dynamic_module(
     return get_class_in_module(class_name, final_module, force_reload=force_download)
 
 
-def custom_object_save(obj: Any, folder: Union[str, os.PathLike], config: Optional[dict] = None) -> list[str]:
+def custom_object_save(obj: Any, folder: str | os.PathLike, config: dict | None = None) -> list[str]:
     """
     Save the modeling files corresponding to a custom model/configuration/tokenizer etc. in a given folder. Optionally
     adds the proper fields in a config.

transformers/feature_extraction_sequence_utils.py

@@ -15,8 +15,6 @@
 Sequence feature extraction class for common feature extractors to preprocess sequences.
 """
 
-from typing import Optional, Union
-
 import numpy as np
 
 from .audio_utils import is_valid_audio, load_audio
@@ -52,19 +50,17 @@ class SequenceFeatureExtractor(FeatureExtractionMixin):
 
     def pad(
         self,
-        processed_features: Union[
-            BatchFeature,
-            list[BatchFeature],
-            dict[str, BatchFeature],
-            dict[str, list[BatchFeature]],
-            list[dict[str, BatchFeature]],
-        ],
-        padding: Union[bool, str, PaddingStrategy] = True,
-        max_length: Optional[int] = None,
+        processed_features: BatchFeature
+        | list[BatchFeature]
+        | dict[str, BatchFeature]
+        | dict[str, list[BatchFeature]]
+        | list[dict[str, BatchFeature]],
+        padding: bool | str | PaddingStrategy = True,
+        max_length: int | None = None,
         truncation: bool = False,
-        pad_to_multiple_of: Optional[int] = None,
-        return_attention_mask: Optional[bool] = None,
-        return_tensors: Optional[Union[str, TensorType]] = None,
+        pad_to_multiple_of: int | None = None,
+        return_attention_mask: bool | None = None,
+        return_tensors: str | TensorType | None = None,
     ) -> BatchFeature:
         """
         Pad input values / input vectors or a batch of input values / input vectors up to predefined length or to the
@@ -224,11 +220,11 @@ class SequenceFeatureExtractor(FeatureExtractionMixin):
 
     def _pad(
         self,
-        processed_features: Union[dict[str, np.ndarray], BatchFeature],
-        max_length: Optional[int] = None,
+        processed_features: dict[str, np.ndarray] | BatchFeature,
+        max_length: int | None = None,
         padding_strategy: PaddingStrategy = PaddingStrategy.DO_NOT_PAD,
-        pad_to_multiple_of: Optional[int] = None,
-        return_attention_mask: Optional[bool] = None,
+        pad_to_multiple_of: int | None = None,
+        return_attention_mask: bool | None = None,
     ) -> dict:
         """
         Pad inputs (on left/right and up to predefined length or max length in the batch)
@@ -296,10 +292,10 @@ class SequenceFeatureExtractor(FeatureExtractionMixin):
 
     def _truncate(
         self,
-        processed_features: Union[dict[str, np.ndarray], BatchFeature],
-        max_length: Optional[int] = None,
-        pad_to_multiple_of: Optional[int] = None,
-        truncation: Optional[bool] = None,
+        processed_features: dict[str, np.ndarray] | BatchFeature,
+        max_length: int | None = None,
+        pad_to_multiple_of: int | None = None,
+        truncation: bool | None = None,
     ):
         """
         Truncate inputs to predefined length or max length in the batch
@@ -369,7 +365,7 @@ class SequenceFeatureExtractor(FeatureExtractionMixin):
 
         return padding_strategy
 
-    def fetch_audio(self, audio_url_or_urls: Union[str, list[str], list[list[str]]]):
+    def fetch_audio(self, audio_url_or_urls: str | list[str] | list[list[str]]):
         """
         Convert a single or a list of urls into the corresponding `np.ndarray` objects.
 

transformers/feature_extraction_utils.py

@@ -19,7 +19,7 @@ import copy
 import json
 import os
 from collections import UserDict
-from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, TypeVar, Union
 
 import numpy as np
 from huggingface_hub import create_repo, is_offline_mode
@@ -74,9 +74,9 @@ class BatchFeature(UserDict):
 
     def __init__(
         self,
-        data: Optional[dict[str, Any]] = None,
-        tensor_type: Union[None, str, TensorType] = None,
-        skip_tensor_conversion: Optional[Union[list[str], set[str]]] = None,
+        data: dict[str, Any] | None = None,
+        tensor_type: None | str | TensorType = None,
+        skip_tensor_conversion: list[str] | set[str] | None = None,
     ):
         super().__init__(data)
         self.convert_to_tensors(tensor_type=tensor_type, skip_tensor_conversion=skip_tensor_conversion)
@@ -104,7 +104,7 @@ class BatchFeature(UserDict):
         if "data" in state:
             self.data = state["data"]
 
-    def _get_is_as_tensor_fns(self, tensor_type: Optional[Union[str, TensorType]] = None):
+    def _get_is_as_tensor_fns(self, tensor_type: str | TensorType | None = None):
         if tensor_type is None:
             return None, None
 
@@ -156,8 +156,8 @@ class BatchFeature(UserDict):
 
     def convert_to_tensors(
         self,
-        tensor_type: Optional[Union[str, TensorType]] = None,
-        skip_tensor_conversion: Optional[Union[list[str], set[str]]] = None,
+        tensor_type: str | TensorType | None = None,
+        skip_tensor_conversion: list[str] | set[str] | None = None,
     ):
         """
         Convert the inner content to tensors.
@@ -282,11 +282,11 @@ class FeatureExtractionMixin(PushToHubMixin):
     @classmethod
     def from_pretrained(
         cls: type[SpecificFeatureExtractorType],
-        pretrained_model_name_or_path: Union[str, os.PathLike],
-        cache_dir: Optional[Union[str, os.PathLike]] = None,
+        pretrained_model_name_or_path: str | os.PathLike,
+        cache_dir: str | os.PathLike | None = None,
         force_download: bool = False,
         local_files_only: bool = False,
-        token: Optional[Union[str, bool]] = None,
+        token: str | bool | None = None,
         revision: str = "main",
         **kwargs,
     ) -> SpecificFeatureExtractorType:
@@ -376,7 +376,7 @@ class FeatureExtractionMixin(PushToHubMixin):
 
         return cls.from_dict(feature_extractor_dict, **kwargs)
 
-    def save_pretrained(self, save_directory: Union[str, os.PathLike], push_to_hub: bool = False, **kwargs):
+    def save_pretrained(self, save_directory: str | os.PathLike, push_to_hub: bool = False, **kwargs):
         """
         Save a feature_extractor object to the directory `save_directory`, so that it can be re-loaded using the
         [`~feature_extraction_utils.FeatureExtractionMixin.from_pretrained`] class method.
@@ -426,7 +426,7 @@ class FeatureExtractionMixin(PushToHubMixin):
 
     @classmethod
     def get_feature_extractor_dict(
-        cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs
+        cls, pretrained_model_name_or_path: str | os.PathLike, **kwargs
     ) -> tuple[dict[str, Any], dict[str, Any]]:
         """
         From a `pretrained_model_name_or_path`, resolve to a dictionary of parameters, to be used for instantiating a
@@ -591,7 +591,7 @@ class FeatureExtractionMixin(PushToHubMixin):
         return output
 
     @classmethod
-    def from_json_file(cls, json_file: Union[str, os.PathLike]) -> "FeatureExtractionMixin":
+    def from_json_file(cls, json_file: str | os.PathLike) -> "FeatureExtractionMixin":
         """
         Instantiates a feature extractor of type [`~feature_extraction_utils.FeatureExtractionMixin`] from the path to
         a JSON file of parameters.
@@ -624,7 +624,7 @@ class FeatureExtractionMixin(PushToHubMixin):
 
         return json.dumps(dictionary, indent=2, sort_keys=True) + "\n"
 
-    def to_json_file(self, json_file_path: Union[str, os.PathLike]):
+    def to_json_file(self, json_file_path: str | os.PathLike):
         """
         Save this instance to a JSON file.
 

transformers/generation/candidate_generator.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright 2023 The HuggingFace Inc. team.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -489,7 +488,7 @@ class AssistedCandidateGeneratorDifferentTokenizers(AssistedCandidateGenerator):
             new_tokens_only: 2D array of shape (batch_size, new_token_length), represents the new tokens that are not in prompt
             discrepancy_only: 2D array of shape (batch_size, discrepancy_length), represents the new tokens that are in prompt but not in prompt_plus_new_tokens
         """
-        compare_mat = prompt_plus_new_tokens.T == prompt
+        compare_mat = prompt == prompt_plus_new_tokens.T
         if not torch.is_tensor(compare_mat):
             compare_mat = torch.tensor(compare_mat)