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

transformers/models/ernie4_5_vl_moe/processing_ernie4_5_vl_moe.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright 2025 Baidu and HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,7 +14,6 @@
 import os.path
 from pathlib import Path
 from shutil import SameFileError, copyfile
-from typing import Optional, Union
 
 import numpy as np
 
@@ -83,9 +81,9 @@ class Ernie4_5_VL_MoeProcessor(ProcessorMixin):
 
     def __call__(
         self,
-        images: Optional[ImageInput] = None,
-        text: Union[TextInput, PreTokenizedInput, list[TextInput], list[PreTokenizedInput]] = None,
-        videos: Optional[VideoInput] = None,
+        images: ImageInput | None = None,
+        text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] = None,
+        videos: VideoInput | None = None,
         **kwargs: Unpack[Ernie4_5_VL_MoeProcessorKwargs],
     ) -> BatchFeature:
         """

transformers/models/ernie4_5_vl_moe/video_processing_ernie4_5_vl_moe.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright 2025 Baidu and HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +15,7 @@ import os.path
 from functools import partial
 from pathlib import Path
 from shutil import SameFileError, copyfile
-from typing import Any, Optional, Union
+from typing import Any
 
 import numpy as np
 import torch
@@ -130,7 +129,7 @@ class Ernie4_5_VL_MoeVideoProcessor(BaseVideoProcessor):
 
     @classmethod
     def get_video_processor_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]]:
         """Overriden to additionally load the font for drawing on frames."""
         cache_dir = kwargs.pop("cache_dir", None)
@@ -283,7 +282,7 @@ class Ernie4_5_VL_MoeVideoProcessor(BaseVideoProcessor):
 
         return output
 
-    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):
         """We additionally save a copy of the font to the `save_directory` (if we found a file there)"""
         os.makedirs(save_directory, exist_ok=True)
 
@@ -297,7 +296,7 @@ class Ernie4_5_VL_MoeVideoProcessor(BaseVideoProcessor):
 
     def _further_process_kwargs(
         self,
-        size: Optional[SizeDict] = None,
+        size: SizeDict | None = None,
         **kwargs,
     ) -> dict:
         """
@@ -312,10 +311,10 @@ class Ernie4_5_VL_MoeVideoProcessor(BaseVideoProcessor):
     def sample_frames(
         self,
         metadata: VideoMetadata,
-        min_frames: Optional[int] = None,
-        max_frames: Optional[int] = None,
-        num_frames: Optional[int] = None,
-        fps: Optional[Union[int, float]] = None,
+        min_frames: int | None = None,
+        max_frames: int | None = None,
+        num_frames: int | None = None,
+        fps: int | float | None = None,
         **kwargs,
     ):
         if fps is not None and num_frames is not None:
@@ -387,9 +386,9 @@ class Ernie4_5_VL_MoeVideoProcessor(BaseVideoProcessor):
     def _prepare_input_videos(
         self,
         videos: VideoInput,
-        input_data_format: Optional[Union[str, ChannelDimension]] = None,
-        device: Optional[str] = None,
-        video_metadata: Optional[list[VideoMetadata]] = None,
+        input_data_format: str | ChannelDimension | None = None,
+        device: str | None = None,
+        video_metadata: list[VideoMetadata] | None = None,
         draw_on_frames: bool = True,
     ) -> list["torch.Tensor"]:
         """
@@ -448,16 +447,16 @@ class Ernie4_5_VL_MoeVideoProcessor(BaseVideoProcessor):
         videos: list[torch.Tensor],
         do_convert_rgb: bool = True,
         do_resize: bool = True,
-        size: Optional[SizeDict] = None,
+        size: SizeDict | None = None,
         interpolation: PILImageResampling = PILImageResampling.BICUBIC,
         do_rescale: bool = True,
         rescale_factor: float = 1 / 255.0,
         do_normalize: bool = True,
-        image_mean: Optional[Union[float, list[float]]] = None,
-        image_std: Optional[Union[float, list[float]]] = None,
-        patch_size: Optional[int] = None,
-        merge_size: Optional[int] = None,
-        return_tensors: Optional[Union[str, TensorType]] = None,
+        image_mean: float | list[float] | None = None,
+        image_std: float | list[float] | None = None,
+        patch_size: int | None = None,
+        merge_size: int | None = None,
+        return_tensors: str | TensorType | None = None,
         **kwargs,
     ):
         # Group videos by size for batched resizing

transformers/models/esm/configuration_esm.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright 2022 Meta and The HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,7 +14,6 @@
 """ESM model configuration"""
 
 from dataclasses import asdict, dataclass
-from typing import Optional
 
 from ...configuration_utils import PreTrainedConfig
 from ...utils import logging
@@ -92,7 +90,7 @@ class TrunkConfig:
     layer_drop: float = 0
     cpu_grad_checkpoint: bool = False
     max_recycles: int = 4
-    chunk_size: Optional[int] = 128
+    chunk_size: int | None = 128
     structure_module: "StructureModuleConfig" = None
 
     def __post_init__(self):
@@ -147,7 +145,7 @@ class TrunkConfig:
 
 @dataclass
 class EsmFoldConfig:
-    esm_type: Optional[str] = None
+    esm_type: str | None = None
     fp16_esm: bool = True
     use_esm_attn_map: bool = False
     esm_ablate_pairwise: bool = False

transformers/models/esm/modeling_esm.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright 2022 Meta and The HuggingFace Inc. team. All rights reserved.
 # Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
 #
@@ -17,7 +16,6 @@
 
 import math
 from collections.abc import Callable
-from typing import Optional, Union
 
 import torch
 from torch import nn
@@ -260,8 +258,8 @@ def eager_attention_forward(
     query: torch.Tensor,
     key: torch.Tensor,
     value: torch.Tensor,
-    attention_mask: Optional[torch.Tensor],
-    scaling: Optional[float] = None,
+    attention_mask: torch.Tensor | None,
+    scaling: float | None = None,
     dropout: float = 0.0,
     **kwargs: Unpack[TransformersKwargs],
 ):
@@ -320,9 +318,9 @@ class EsmSelfAttention(nn.Module):
     def forward(
         self,
         hidden_states: torch.Tensor,
-        attention_mask: Optional[torch.FloatTensor] = None,
-        encoder_hidden_states: Optional[torch.FloatTensor] = None,
-        encoder_attention_mask: Optional[torch.FloatTensor] = None,
+        attention_mask: torch.FloatTensor | None = None,
+        encoder_hidden_states: torch.FloatTensor | None = None,
+        encoder_attention_mask: torch.FloatTensor | None = None,
         **kwargs: Unpack[TransformersKwargs],
     ) -> tuple[torch.Tensor]:
         batch_size, seq_length = hidden_states.shape[:-1]
@@ -615,14 +613,14 @@ class EsmModel(EsmPreTrainedModel):
     @auto_docstring
     def forward(
         self,
-        input_ids: Optional[torch.Tensor] = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.Tensor] = None,
-        inputs_embeds: Optional[torch.Tensor] = None,
-        encoder_hidden_states: Optional[torch.Tensor] = None,
-        encoder_attention_mask: Optional[torch.Tensor] = None,
+        input_ids: torch.Tensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.Tensor | None = None,
+        inputs_embeds: torch.Tensor | None = None,
+        encoder_hidden_states: torch.Tensor | None = None,
+        encoder_attention_mask: torch.Tensor | None = None,
         **kwargs: Unpack[TransformersKwargs],
-    ) -> Union[tuple[torch.Tensor], BaseModelOutputWithPoolingAndCrossAttentions]:
+    ) -> tuple[torch.Tensor] | BaseModelOutputWithPoolingAndCrossAttentions:
         r"""
         input_ids (`torch.LongTensor` of shape `((batch_size, sequence_length))`):
             Indices of input sequence tokens in the vocabulary.
@@ -750,15 +748,15 @@ class EsmForMaskedLM(EsmPreTrainedModel):
     @auto_docstring
     def forward(
         self,
-        input_ids: Optional[torch.LongTensor] = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        encoder_hidden_states: Optional[torch.FloatTensor] = None,
-        encoder_attention_mask: Optional[torch.Tensor] = None,
-        labels: Optional[torch.LongTensor] = None,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        encoder_hidden_states: torch.FloatTensor | None = None,
+        encoder_attention_mask: torch.Tensor | None = None,
+        labels: torch.LongTensor | None = None,
         **kwargs: Unpack[TransformersKwargs],
-    ) -> Union[tuple, MaskedLMOutput]:
+    ) -> tuple | MaskedLMOutput:
         r"""
         labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
             Labels for computing the masked language modeling loss. Indices should be in `[-100, 0, ...,
@@ -838,13 +836,13 @@ class EsmForSequenceClassification(EsmPreTrainedModel):
     @auto_docstring
     def forward(
         self,
-        input_ids: Optional[torch.LongTensor] = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        labels: Optional[torch.LongTensor] = None,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        labels: torch.LongTensor | None = None,
         **kwargs: Unpack[TransformersKwargs],
-    ) -> Union[tuple, SequenceClassifierOutput]:
+    ) -> tuple | SequenceClassifierOutput:
         r"""
         labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
             Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
@@ -911,13 +909,13 @@ class EsmForTokenClassification(EsmPreTrainedModel):
     @auto_docstring
     def forward(
         self,
-        input_ids: Optional[torch.LongTensor] = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        labels: Optional[torch.LongTensor] = None,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        labels: torch.LongTensor | None = None,
         **kwargs: Unpack[TransformersKwargs],
-    ) -> Union[tuple, TokenClassifierOutput]:
+    ) -> tuple | TokenClassifierOutput:
         r"""
         labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
             Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`.

transformers/models/esm/modeling_esmfold.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright 2022 Meta and The HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,7 +16,6 @@ import sys
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass
 from functools import partial
-from typing import Optional, Union
 
 import numpy as np
 import torch
@@ -111,29 +109,29 @@ class EsmForProteinFoldingOutput(ModelOutput):
         Per-sample maximum predicted error.
     """
 
-    frames: Optional[torch.FloatTensor] = None
-    sidechain_frames: Optional[torch.FloatTensor] = None
-    unnormalized_angles: Optional[torch.FloatTensor] = None
-    angles: Optional[torch.FloatTensor] = None
-    positions: Optional[torch.FloatTensor] = None
-    states: Optional[torch.FloatTensor] = None
-    s_s: Optional[torch.FloatTensor] = None
-    s_z: Optional[torch.FloatTensor] = None
-    distogram_logits: Optional[torch.FloatTensor] = None
-    lm_logits: Optional[torch.FloatTensor] = None
-    aatype: Optional[torch.FloatTensor] = None
-    atom14_atom_exists: Optional[torch.FloatTensor] = None
-    residx_atom14_to_atom37: Optional[torch.FloatTensor] = None
-    residx_atom37_to_atom14: Optional[torch.FloatTensor] = None
-    atom37_atom_exists: Optional[torch.FloatTensor] = None
-    residue_index: Optional[torch.FloatTensor] = None
-    lddt_head: Optional[torch.FloatTensor] = None
-    plddt: Optional[torch.FloatTensor] = None
-    ptm_logits: Optional[torch.FloatTensor] = None
-    ptm: Optional[torch.FloatTensor] = None
-    aligned_confidence_probs: Optional[torch.FloatTensor] = None
-    predicted_aligned_error: Optional[torch.FloatTensor] = None
-    max_predicted_aligned_error: Optional[torch.FloatTensor] = None
+    frames: torch.FloatTensor | None = None
+    sidechain_frames: torch.FloatTensor | None = None
+    unnormalized_angles: torch.FloatTensor | None = None
+    angles: torch.FloatTensor | None = None
+    positions: torch.FloatTensor | None = None
+    states: torch.FloatTensor | None = None
+    s_s: torch.FloatTensor | None = None
+    s_z: torch.FloatTensor | None = None
+    distogram_logits: torch.FloatTensor | None = None
+    lm_logits: torch.FloatTensor | None = None
+    aatype: torch.FloatTensor | None = None
+    atom14_atom_exists: torch.FloatTensor | None = None
+    residx_atom14_to_atom37: torch.FloatTensor | None = None
+    residx_atom37_to_atom14: torch.FloatTensor | None = None
+    atom37_atom_exists: torch.FloatTensor | None = None
+    residue_index: torch.FloatTensor | None = None
+    lddt_head: torch.FloatTensor | None = None
+    plddt: torch.FloatTensor | None = None
+    ptm_logits: torch.FloatTensor | None = None
+    ptm: torch.FloatTensor | None = None
+    aligned_confidence_probs: torch.FloatTensor | None = None
+    predicted_aligned_error: torch.FloatTensor | None = None
+    max_predicted_aligned_error: torch.FloatTensor | None = None
 
 
 def is_fp16_enabled(device_type):
@@ -222,7 +220,7 @@ class EsmFoldLinear(nn.Linear):
         out_dim: int,
         bias: bool = True,
         init: str = "default",
-        init_fn: Optional[Callable[[torch.Tensor, torch.Tensor], None]] = None,
+        init_fn: Callable[[torch.Tensor, torch.Tensor], None] | None = None,
     ):
         """
         Args:
@@ -383,13 +381,13 @@ class EsmFoldAttention(nn.Module):
         self,
         q_x: torch.Tensor,
         kv_x: torch.Tensor,
-        biases: Optional[list[torch.Tensor]] = None,
+        biases: list[torch.Tensor] | None = None,
         use_memory_efficient_kernel: bool = False,
         use_lma: bool = False,
         lma_q_chunk_size: int = 1024,
         lma_kv_chunk_size: int = 4096,
         use_flash: bool = False,
-        flash_mask: Optional[torch.Tensor] = None,
+        flash_mask: torch.Tensor | None = None,
     ) -> torch.Tensor:
         """
         Args:
@@ -496,8 +494,8 @@ class EsmFoldTriangleAttention(nn.Module):
     def forward(
         self,
         x: torch.Tensor,
-        mask: Optional[torch.Tensor] = None,
-        chunk_size: Optional[int] = None,
+        mask: torch.Tensor | None = None,
+        chunk_size: int | None = None,
         use_memory_efficient_kernel: bool = False,
         use_lma: bool = False,
         inplace_safe: bool = False,
@@ -576,7 +574,7 @@ class EsmFoldTriangleMultiplicativeUpdate(nn.Module):
         self.sigmoid = nn.Sigmoid()
 
     def _combine_projections(
-        self, a: torch.Tensor, b: torch.Tensor, _inplace_chunk_size: Optional[int] = None
+        self, a: torch.Tensor, b: torch.Tensor, _inplace_chunk_size: int | None = None
     ) -> torch.Tensor:
         if self._outgoing:
             a = permute_final_dims(a, (2, 0, 1))
@@ -604,8 +602,8 @@ class EsmFoldTriangleMultiplicativeUpdate(nn.Module):
     def _inference_forward(
         self,
         z: torch.Tensor,
-        mask: Optional[torch.Tensor] = None,
-        inplace_chunk_size: Optional[int] = None,
+        mask: torch.Tensor | None = None,
+        inplace_chunk_size: int | None = None,
         with_add: bool = True,
     ):
         """
@@ -831,10 +829,10 @@ class EsmFoldTriangleMultiplicativeUpdate(nn.Module):
     def forward(
         self,
         z: torch.Tensor,
-        mask: Optional[torch.Tensor] = None,
+        mask: torch.Tensor | None = None,
         inplace_safe: bool = False,
         _add_with_inplace: bool = False,
-        _inplace_chunk_size: Optional[int] = 256,
+        _inplace_chunk_size: int | None = 256,
     ) -> torch.Tensor:
         """
         Args:
@@ -1010,7 +1008,7 @@ class EsmFoldDropout(nn.Module):
     Implementation of dropout with the ability to share the dropout mask along a particular dimension.
     """
 
-    def __init__(self, r: float, batch_dim: Union[int, list[int]]):
+    def __init__(self, r: float, batch_dim: int | list[int]):
         super().__init__()
 
         self.r = r
@@ -1416,11 +1414,11 @@ class EsmFoldInvariantPointAttention(nn.Module):
     def forward(
         self,
         s: torch.Tensor,
-        z: Optional[torch.Tensor],
+        z: torch.Tensor | None,
         r: Rigid,
         mask: torch.Tensor,
         _offload_inference: bool = False,
-        _z_reference_list: Optional[Sequence[torch.Tensor]] = None,
+        _z_reference_list: Sequence[torch.Tensor] | None = None,
     ) -> torch.Tensor:
         """
         Args:
@@ -2051,11 +2049,11 @@ class EsmForProteinFolding(EsmPreTrainedModel):
     def forward(
         self,
         input_ids: torch.Tensor,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.Tensor] = None,
-        masking_pattern: Optional[torch.Tensor] = None,
-        num_recycles: Optional[int] = None,
-        output_hidden_states: Optional[bool] = False,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.Tensor | None = None,
+        masking_pattern: torch.Tensor | None = None,
+        num_recycles: int | None = None,
+        output_hidden_states: bool | None = False,
     ) -> EsmForProteinFoldingOutput:
         r"""
         masking_pattern (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
@@ -2225,7 +2223,7 @@ class EsmForProteinFolding(EsmPreTrainedModel):
     @torch.no_grad()
     def infer(
         self,
-        seqs: Union[str, list[str]],
+        seqs: str | list[str],
         position_ids=None,
     ):
         if isinstance(seqs, str):

transformers/models/esm/openfold_utils/chunk_utils.py

@@ -15,14 +15,14 @@ import logging
 import math
 from collections.abc import Callable, Iterable, Sequence
 from functools import partial
-from typing import Any, Optional, Union
+from typing import Any
 
 import torch
 
 from .tensor_utils import tensor_tree_map, tree_map
 
 
-def _fetch_dims(tree: Union[dict, list, tuple, torch.Tensor]) -> list[tuple[int, ...]]:
+def _fetch_dims(tree: dict | list | tuple | torch.Tensor) -> list[tuple[int, ...]]:
     shapes = []
     if isinstance(tree, dict):
         for v in tree.values():
@@ -53,8 +53,8 @@ def _get_minimal_slice_set(
     start: Sequence[int],
     end: Sequence[int],
     dims: Sequence[int],
-    start_edges: Optional[Sequence[bool]] = None,
-    end_edges: Optional[Sequence[bool]] = None,
+    start_edges: Sequence[bool] | None = None,
+    end_edges: Sequence[bool] | None = None,
 ) -> list[tuple[slice, ...]]:
     """
     Produces an ordered sequence of tensor slices that, when used in sequence on a tensor with shape dims, yields
@@ -320,8 +320,8 @@ class ChunkSizeTuner:
         max_chunk_size: int = 512,
     ):
         self.max_chunk_size = max_chunk_size
-        self.cached_chunk_size: Optional[int] = None
-        self.cached_arg_data: Optional[tuple] = None
+        self.cached_chunk_size: int | None = None
+        self.cached_arg_data: tuple | None = None
 
     def _determine_favorable_chunk_size(self, fn: Callable, args: tuple, min_chunk_size: int) -> int:
         logging.info("Tuning chunk size...")

transformers/models/esm/openfold_utils/loss.py

@@ -13,7 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional
 
 import torch
 
@@ -73,7 +72,7 @@ def compute_predicted_aligned_error(
 
 def compute_tm(
     logits: torch.Tensor,
-    residue_weights: Optional[torch.Tensor] = None,
+    residue_weights: torch.Tensor | None = None,
     max_bin: int = 31,
     no_bins: int = 64,
     eps: float = 1e-8,

transformers/models/esm/openfold_utils/protein.py

@@ -19,7 +19,7 @@ import dataclasses
 import re
 import string
 from collections.abc import Iterator, Mapping, Sequence
-from typing import Any, Optional
+from typing import Any
 
 import numpy as np
 
@@ -56,17 +56,17 @@ class Protein:
     b_factors: np.ndarray  # [num_res, num_atom_type]
 
     # Chain indices for multi-chain predictions
-    chain_index: Optional[np.ndarray] = None
+    chain_index: np.ndarray | None = None
 
     # Optional remark about the protein. Included as a comment in output PDB
     # files
-    remark: Optional[str] = None
+    remark: str | None = None
 
     # Templates used to generate this protein (prediction-only)
-    parents: Optional[Sequence[str]] = None
+    parents: Sequence[str] | None = None
 
     # Chain corresponding to each parent
-    parents_chain_index: Optional[Sequence[int]] = None
+    parents_chain_index: Sequence[int] | None = None
 
 
 def from_proteinnet_string(proteinnet_str: str) -> Protein:
@@ -79,7 +79,7 @@ def from_proteinnet_string(proteinnet_str: str) -> Protein:
     atom_positions = None
     atom_mask = None
     for g in groups:
-        if "[PRIMARY]" == g[0]:
+        if g[0] == "[PRIMARY]":
             seq = g[1][0].strip()
             for i in range(len(seq)):
                 if seq[i] not in residue_constants.restypes:
@@ -87,7 +87,7 @@ def from_proteinnet_string(proteinnet_str: str) -> Protein:
             aatype = np.array(
                 [residue_constants.restype_order.get(res_symbol, residue_constants.restype_num) for res_symbol in seq]
             )
-        elif "[TERTIARY]" == g[0]:
+        elif g[0] == "[TERTIARY]":
             tertiary: list[list[float]] = []
             for axis in range(3):
                 tertiary.append(list(map(float, g[1][axis].split())))
@@ -96,7 +96,7 @@ def from_proteinnet_string(proteinnet_str: str) -> Protein:
             for i, atom in enumerate(atoms):
                 atom_positions[:, residue_constants.atom_order[atom], :] = np.transpose(tertiary_np[:, i::3])
             atom_positions *= PICO_TO_ANGSTROM
-        elif "[MASK]" == g[0]:
+        elif g[0] == "[MASK]":
             mask = np.array(list(map({"-": 0, "+": 1}.get, g[1][0].strip())))
             atom_mask = np.zeros(
                 (
@@ -300,11 +300,11 @@ def ideal_atom_mask(prot: Protein) -> np.ndarray:
 def from_prediction(
     features: FeatureDict,
     result: ModelOutput,
-    b_factors: Optional[np.ndarray] = None,
-    chain_index: Optional[np.ndarray] = None,
-    remark: Optional[str] = None,
-    parents: Optional[Sequence[str]] = None,
-    parents_chain_index: Optional[Sequence[int]] = None,
+    b_factors: np.ndarray | None = None,
+    chain_index: np.ndarray | None = None,
+    remark: str | None = None,
+    parents: Sequence[str] | None = None,
+    parents_chain_index: Sequence[int] | None = None,
 ) -> Protein:
     """Assembles a protein from a prediction.
 

transformers/models/esm/openfold_utils/tensor_utils.py

@@ -15,7 +15,7 @@
 
 from collections.abc import Callable
 from functools import partial
-from typing import Any, TypeVar, Union, overload
+from typing import Any, TypeVar, overload
 
 import torch
 import torch.nn as nn
@@ -77,13 +77,13 @@ def one_hot(x: torch.Tensor, v_bins: torch.Tensor) -> torch.Tensor:
 
 
 def batched_gather(data: torch.Tensor, inds: torch.Tensor, dim: int = 0, no_batch_dims: int = 0) -> torch.Tensor:
-    ranges: list[Union[slice, torch.Tensor]] = []
+    ranges: list[slice | torch.Tensor] = []
     for i, s in enumerate(data.shape[:no_batch_dims]):
         r = torch.arange(s)
         r = r.view(*(*((1,) * i), -1, *((1,) * (len(inds.shape) - i - 1))))
         ranges.append(r)
 
-    remaining_dims: list[Union[slice, torch.Tensor]] = [slice(None) for _ in range(len(data.shape) - no_batch_dims)]
+    remaining_dims: list[slice | torch.Tensor] = [slice(None) for _ in range(len(data.shape) - no_batch_dims)]
     remaining_dims[dim - no_batch_dims if dim >= 0 else dim] = inds
     ranges.extend(remaining_dims)
     # Matt note: Editing this to get around the behaviour of using a list as an array index changing
@@ -95,9 +95,9 @@ T = TypeVar("T")
 
 
 def dict_map(
-    fn: Callable[[T], Any], dic: dict[Any, Union[dict, list, tuple, T]], leaf_type: type[T]
-) -> dict[Any, Union[dict, list, tuple, Any]]:
-    new_dict: dict[Any, Union[dict, list, tuple, Any]] = {}
+    fn: Callable[[T], Any], dic: dict[Any, dict | list | tuple | T], leaf_type: type[T]
+) -> dict[Any, dict | list | tuple | Any]:
+    new_dict: dict[Any, dict | list | tuple | Any] = {}
     for k, v in dic.items():
         if isinstance(v, dict):
             new_dict[k] = dict_map(fn, v, leaf_type)

transformers/models/esm/tokenization_esm.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright 2022 Meta and The HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,7 +14,6 @@
 """Tokenization classes for ESM."""
 
 import os
-from typing import Optional
 
 from ...tokenization_python import PreTrainedTokenizer
 from ...utils import logging
@@ -89,7 +87,7 @@ class EsmTokenizer(PreTrainedTokenizer):
         return self._id_to_token.get(index, self.unk_token)
 
     def build_inputs_with_special_tokens(
-        self, token_ids_0: list[int], token_ids_1: Optional[list[int]] = None
+        self, token_ids_0: list[int], token_ids_1: list[int] | None = None
     ) -> list[int]:
         cls = [self.cls_token_id]
         sep = [self.eos_token_id]  # No sep token in ESM vocabulary
@@ -103,7 +101,7 @@ class EsmTokenizer(PreTrainedTokenizer):
         return cls + token_ids_0 + sep + token_ids_1 + sep  # Multiple inputs always have an EOS token
 
     def get_special_tokens_mask(
-        self, token_ids_0: list, token_ids_1: Optional[list] = None, already_has_special_tokens: bool = False
+        self, token_ids_0: list, token_ids_1: list | None = None, already_has_special_tokens: bool = False
     ) -> list[int]:
         """
         Retrieves sequence ids from a token list that has no special tokens added. This method is called when adding