huggingface-hub 0.35.0rc0__py3-none-any.whl → 1.0.0rc0__py3-none-any.whl

huggingface_hub/serialization/_dduf.py

@@ -7,7 +7,7 @@ import zipfile
 from contextlib import contextmanager
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Dict, Generator, Iterable, Tuple, Union
+from typing import Any, Generator, Iterable, Union
 
 from ..errors import DDUFCorruptedFileError, DDUFExportError, DDUFInvalidEntryNameError
 
@@ -87,7 +87,7 @@ class DDUFEntry:
             return f.read(self.length).decode(encoding=encoding)
 
 
-def read_dduf_file(dduf_path: Union[os.PathLike, str]) -> Dict[str, DDUFEntry]:
+def read_dduf_file(dduf_path: Union[os.PathLike, str]) -> dict[str, DDUFEntry]:
     """
     Read a DDUF file and return a dictionary of entries.
 
@@ -98,7 +98,7 @@ def read_dduf_file(dduf_path: Union[os.PathLike, str]) -> Dict[str, DDUFEntry]:
             The path to the DDUF file to read.
 
     Returns:
-        `Dict[str, DDUFEntry]`:
+        `dict[str, DDUFEntry]`:
             A dictionary of [`DDUFEntry`] indexed by filename.
 
     Raises:
@@ -157,7 +157,7 @@ def read_dduf_file(dduf_path: Union[os.PathLike, str]) -> Dict[str, DDUFEntry]:
 
 
 def export_entries_as_dduf(
-    dduf_path: Union[str, os.PathLike], entries: Iterable[Tuple[str, Union[str, Path, bytes]]]
+    dduf_path: Union[str, os.PathLike], entries: Iterable[tuple[str, Union[str, Path, bytes]]]
 ) -> None:
     """Write a DDUF file from an iterable of entries.
 
@@ -167,7 +167,7 @@ def export_entries_as_dduf(
     Args:
         dduf_path (`str` or `os.PathLike`):
             The path to the DDUF file to write.
-        entries (`Iterable[Tuple[str, Union[str, Path, bytes]]]`):
+        entries (`Iterable[tuple[str, Union[str, Path, bytes]]]`):
             An iterable of entries to write in the DDUF file. Each entry is a tuple with the filename and the content.
             The filename should be the path to the file in the DDUF archive.
             The content can be a string or a pathlib.Path representing a path to a file on the local disk or directly the content as bytes.
@@ -201,7 +201,7 @@ def export_entries_as_dduf(
         >>> pipe = DiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4")
         ... # ... do some work with the pipeline
 
-        >>> def as_entries(pipe: DiffusionPipeline) -> Generator[Tuple[str, bytes], None, None]:
+        >>> def as_entries(pipe: DiffusionPipeline) -> Generator[tuple[str, bytes], None, None]:
         ...     # Build an generator that yields the entries to add to the DDUF file.
         ...     # The first element of the tuple is the filename in the DDUF archive (must use UNIX separator!). The second element is the content of the file.
         ...     # Entries will be evaluated lazily when the DDUF file is created (only 1 entry is loaded in memory at a time)
@@ -267,7 +267,7 @@ def export_folder_as_dduf(dduf_path: Union[str, os.PathLike], folder_path: Union
     """
     folder_path = Path(folder_path)
 
-    def _iterate_over_folder() -> Iterable[Tuple[str, Path]]:
+    def _iterate_over_folder() -> Iterable[tuple[str, Path]]:
         for path in Path(folder_path).glob("**/*"):
             if not path.is_file():
                 continue

huggingface_hub/serialization/_torch.py

@@ -20,7 +20,7 @@ import re
 from collections import defaultdict, namedtuple
 from functools import lru_cache
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, Iterable, List, NamedTuple, Optional, Set, Tuple, Union
+from typing import TYPE_CHECKING, Any, Iterable, NamedTuple, Optional, Union
 
 from packaging import version
 
@@ -43,10 +43,10 @@ def save_torch_model(
     filename_pattern: Optional[str] = None,
     force_contiguous: bool = True,
     max_shard_size: Union[int, str] = MAX_SHARD_SIZE,
-    metadata: Optional[Dict[str, str]] = None,
+    metadata: Optional[dict[str, str]] = None,
     safe_serialization: bool = True,
     is_main_process: bool = True,
-    shared_tensors_to_discard: Optional[List[str]] = None,
+    shared_tensors_to_discard: Optional[list[str]] = None,
 ):
     """
     Saves a given torch model to disk, handling sharding and shared tensors issues.
@@ -92,7 +92,7 @@ def save_torch_model(
             that reason. Defaults to `True`.
         max_shard_size (`int` or `str`, *optional*):
             The maximum size of each shard, in bytes. Defaults to 5GB.
-        metadata (`Dict[str, str]`, *optional*):
+        metadata (`dict[str, str]`, *optional*):
             Extra information to save along with the model. Some metadata will be added for each dropped tensors.
             This information will not be enough to recover the entire shared structure but might help understanding
             things.
@@ -104,7 +104,7 @@ def save_torch_model(
             Whether the process calling this is the main process or not. Useful when in distributed training like
             TPUs and need to call this function from all processes. In this case, set `is_main_process=True` only on
             the main process to avoid race conditions. Defaults to True.
-        shared_tensors_to_discard (`List[str]`, *optional*):
+        shared_tensors_to_discard (`list[str]`, *optional*):
             List of tensor names to drop when saving shared tensors. If not provided and shared tensors are
             detected, it will drop the first name alphabetically.
 
@@ -137,16 +137,16 @@ def save_torch_model(
 
 
 def save_torch_state_dict(
-    state_dict: Dict[str, "torch.Tensor"],
+    state_dict: dict[str, "torch.Tensor"],
     save_directory: Union[str, Path],
     *,
     filename_pattern: Optional[str] = None,
     force_contiguous: bool = True,
     max_shard_size: Union[int, str] = MAX_SHARD_SIZE,
-    metadata: Optional[Dict[str, str]] = None,
+    metadata: Optional[dict[str, str]] = None,
     safe_serialization: bool = True,
     is_main_process: bool = True,
-    shared_tensors_to_discard: Optional[List[str]] = None,
+    shared_tensors_to_discard: Optional[list[str]] = None,
 ) -> None:
     """
     Save a model state dictionary to the disk, handling sharding and shared tensors issues.
@@ -177,7 +177,7 @@ def save_torch_state_dict(
     </Tip>
 
     Args:
-        state_dict (`Dict[str, torch.Tensor]`):
+        state_dict (`dict[str, torch.Tensor]`):
             The state dictionary to save.
         save_directory (`str` or `Path`):
             The directory in which the model will be saved.
@@ -192,7 +192,7 @@ def save_torch_state_dict(
             that reason. Defaults to `True`.
         max_shard_size (`int` or `str`, *optional*):
             The maximum size of each shard, in bytes. Defaults to 5GB.
-        metadata (`Dict[str, str]`, *optional*):
+        metadata (`dict[str, str]`, *optional*):
             Extra information to save along with the model. Some metadata will be added for each dropped tensors.
             This information will not be enough to recover the entire shared structure but might help understanding
             things.
@@ -204,7 +204,7 @@ def save_torch_state_dict(
             Whether the process calling this is the main process or not. Useful when in distributed training like
             TPUs and need to call this function from all processes. In this case, set `is_main_process=True` only on
             the main process to avoid race conditions. Defaults to True.
-        shared_tensors_to_discard (`List[str]`, *optional*):
+        shared_tensors_to_discard (`list[str]`, *optional*):
             List of tensor names to drop when saving shared tensors. If not provided and shared tensors are
             detected, it will drop the first name alphabetically.
 
@@ -300,7 +300,7 @@ def save_torch_state_dict(
 
 
 def split_torch_state_dict_into_shards(
-    state_dict: Dict[str, "torch.Tensor"],
+    state_dict: dict[str, "torch.Tensor"],
     *,
     filename_pattern: str = constants.SAFETENSORS_WEIGHTS_FILE_PATTERN,
     max_shard_size: Union[int, str] = MAX_SHARD_SIZE,
@@ -329,7 +329,7 @@ def split_torch_state_dict_into_shards(
     </Tip>
 
     Args:
-        state_dict (`Dict[str, torch.Tensor]`):
+        state_dict (`dict[str, torch.Tensor]`):
             The state dictionary to save.
         filename_pattern (`str`, *optional*):
             The pattern to generate the files names in which the model will be saved. Pattern must be a string that
@@ -348,7 +348,7 @@ def split_torch_state_dict_into_shards(
     >>> from safetensors.torch import save_file as safe_save_file
     >>> from huggingface_hub import split_torch_state_dict_into_shards
 
-    >>> def save_state_dict(state_dict: Dict[str, torch.Tensor], save_directory: str):
+    >>> def save_state_dict(state_dict: dict[str, torch.Tensor], save_directory: str):
     ...     state_dict_split = split_torch_state_dict_into_shards(state_dict)
     ...     for filename, tensors in state_dict_split.filename_to_tensors.items():
     ...         shard = {tensor: state_dict[tensor] for tensor in tensors}
@@ -560,7 +560,7 @@ def load_state_dict_from_file(
     map_location: Optional[Union[str, "torch.device"]] = None,
     weights_only: bool = False,
     mmap: bool = False,
-) -> Union[Dict[str, "torch.Tensor"], Any]:
+) -> Union[dict[str, "torch.Tensor"], Any]:
     """
     Loads a checkpoint file, handling both safetensors and pickle checkpoint formats.
 
@@ -580,7 +580,7 @@ def load_state_dict_from_file(
             loading safetensors files, as the `safetensors` library uses memory mapping by default.
 
     Returns:
-        `Union[Dict[str, "torch.Tensor"], Any]`: The loaded checkpoint.
+        `Union[dict[str, "torch.Tensor"], Any]`: The loaded checkpoint.
             - For safetensors files: always returns a dictionary mapping parameter names to tensors.
             - For pickle files: returns any Python object that was pickled (commonly a state dict, but could be
               an entire model, optimizer state, or any other Python object).
@@ -700,7 +700,7 @@ def _validate_keys_for_strict_loading(
         raise RuntimeError(error_message)
 
 
-def _get_unique_id(tensor: "torch.Tensor") -> Union[int, Tuple[Any, ...]]:
+def _get_unique_id(tensor: "torch.Tensor") -> Union[int, tuple[Any, ...]]:
     """Returns a unique id for plain tensor
     or a (potentially nested) Tuple of unique id for the flattened Tensor
     if the input is a wrapper tensor subclass Tensor
@@ -741,7 +741,7 @@ def _get_unique_id(tensor: "torch.Tensor") -> Union[int, Tuple[Any, ...]]:
     return unique_id
 
 
-def get_torch_storage_id(tensor: "torch.Tensor") -> Optional[Tuple["torch.device", Union[int, Tuple[Any, ...]], int]]:
+def get_torch_storage_id(tensor: "torch.Tensor") -> Optional[tuple["torch.device", Union[int, tuple[Any, ...]], int]]:
     """
     Return unique identifier to a tensor storage.
 
@@ -815,7 +815,7 @@ def is_torch_tpu_available(check_device=True):
     return False
 
 
-def storage_ptr(tensor: "torch.Tensor") -> Union[int, Tuple[Any, ...]]:
+def storage_ptr(tensor: "torch.Tensor") -> Union[int, tuple[Any, ...]]:
     """
     Taken from https://github.com/huggingface/safetensors/blob/079781fd0dc455ba0fe851e2b4507c33d0c0d407/bindings/python/py_src/safetensors/torch.py#L11.
     """
@@ -841,10 +841,10 @@ def storage_ptr(tensor: "torch.Tensor") -> Union[int, Tuple[Any, ...]]:
 
 
 def _clean_state_dict_for_safetensors(
-    state_dict: Dict[str, "torch.Tensor"],
-    metadata: Dict[str, str],
+    state_dict: dict[str, "torch.Tensor"],
+    metadata: dict[str, str],
     force_contiguous: bool = True,
-    shared_tensors_to_discard: Optional[List[str]] = None,
+    shared_tensors_to_discard: Optional[list[str]] = None,
 ):
     """Remove shared tensors from state_dict and update metadata accordingly (for reloading).
 
@@ -878,7 +878,7 @@ def _end_ptr(tensor: "torch.Tensor") -> int:
     return stop
 
 
-def _filter_shared_not_shared(tensors: List[Set[str]], state_dict: Dict[str, "torch.Tensor"]) -> List[Set[str]]:
+def _filter_shared_not_shared(tensors: list[set[str]], state_dict: dict[str, "torch.Tensor"]) -> list[set[str]]:
     """
     Taken from https://github.com/huggingface/safetensors/blob/079781fd0dc455ba0fe851e2b4507c33d0c0d407/bindings/python/py_src/safetensors/torch.py#L44
     """
@@ -906,7 +906,7 @@ def _filter_shared_not_shared(tensors: List[Set[str]], state_dict: Dict[str, "to
     return filtered_tensors
 
 
-def _find_shared_tensors(state_dict: Dict[str, "torch.Tensor"]) -> List[Set[str]]:
+def _find_shared_tensors(state_dict: dict[str, "torch.Tensor"]) -> list[set[str]]:
     """
     Taken from https://github.com/huggingface/safetensors/blob/079781fd0dc455ba0fe851e2b4507c33d0c0d407/bindings/python/py_src/safetensors/torch.py#L69.
     """
@@ -943,11 +943,11 @@ def _is_complete(tensor: "torch.Tensor") -> bool:
 
 
 def _remove_duplicate_names(
-    state_dict: Dict[str, "torch.Tensor"],
+    state_dict: dict[str, "torch.Tensor"],
     *,
-    preferred_names: Optional[List[str]] = None,
-    discard_names: Optional[List[str]] = None,
-) -> Dict[str, List[str]]:
+    preferred_names: Optional[list[str]] = None,
+    discard_names: Optional[list[str]] = None,
+) -> dict[str, list[str]]:
     """
     Taken from https://github.com/huggingface/safetensors/blob/079781fd0dc455ba0fe851e2b4507c33d0c0d407/bindings/python/py_src/safetensors/torch.py#L80
     """

huggingface_hub/utils/__init__.py

@@ -50,14 +50,20 @@ from ._experimental import experimental
 from ._fixes import SoftTemporaryDirectory, WeakFileLock, yaml_dump
 from ._git_credential import list_credential_helpers, set_git_credential, unset_git_credential
 from ._headers import build_hf_headers, get_token_to_send
-from ._hf_folder import HfFolder
 from ._http import (
-    configure_http_backend,
+    ASYNC_CLIENT_FACTORY_T,
+    CLIENT_FACTORY_T,
+    HfHubAsyncTransport,
+    HfHubTransport,
+    close_client,
     fix_hf_endpoint_in_url,
+    get_async_session,
     get_session,
     hf_raise_for_status,
     http_backoff,
-    reset_sessions,
+    http_stream_backoff,
+    set_async_client_factory,
+    set_client_factory,
 )
 from ._pagination import paginate
 from ._paths import DEFAULT_IGNORE_PATTERNS, FORBIDDEN_FOLDERS, filter_repo_objects
@@ -105,7 +111,7 @@ from ._safetensors import SafetensorsFileMetadata, SafetensorsRepoMetadata, Tens
 from ._subprocess import capture_output, run_interactive_subprocess, run_subprocess
 from ._telemetry import send_telemetry
 from ._typing import is_jsonable, is_simple_optional_type, unwrap_simple_optional_type
-from ._validators import smoothly_deprecate_use_auth_token, validate_hf_hub_args, validate_repo_id
+from ._validators import validate_hf_hub_args, validate_repo_id
 from ._xet import (
     XetConnectionInfo,
     XetFileData,

huggingface_hub/utils/_auth.py

@@ -19,7 +19,7 @@ import os
 import warnings
 from pathlib import Path
 from threading import Lock
-from typing import Dict, Optional
+from typing import Optional
 
 from .. import constants
 from ._runtime import is_colab_enterprise, is_google_colab
@@ -125,13 +125,13 @@ def _get_token_from_file() -> Optional[str]:
         return None
 
 
-def get_stored_tokens() -> Dict[str, str]:
+def get_stored_tokens() -> dict[str, str]:
     """
     Returns the parsed INI file containing the access tokens.
     The file is located at `HF_STORED_TOKENS_PATH`, defaulting to `~/.cache/huggingface/stored_tokens`.
     If the file does not exist, an empty dictionary is returned.
 
-    Returns: `Dict[str, str]`
+    Returns: `dict[str, str]`
         Key is the token name and value is the token.
     """
     tokens_path = Path(constants.HF_STORED_TOKENS_PATH)
@@ -147,12 +147,12 @@ def get_stored_tokens() -> Dict[str, str]:
     return stored_tokens
 
 
-def _save_stored_tokens(stored_tokens: Dict[str, str]) -> None:
+def _save_stored_tokens(stored_tokens: dict[str, str]) -> None:
     """
     Saves the given configuration to the stored tokens file.
 
     Args:
-        stored_tokens (`Dict[str, str]`):
+        stored_tokens (`dict[str, str]`):
             The stored tokens to save. Key is the token name and value is the token.
     """
     stored_tokens_path = Path(constants.HF_STORED_TOKENS_PATH)

huggingface_hub/utils/_cache_manager.py

@@ -20,7 +20,7 @@ import time
 from collections import defaultdict
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, FrozenSet, List, Literal, Optional, Set, Union
+from typing import Literal, Optional, Union
 
 from huggingface_hub.errors import CacheNotFound, CorruptedCacheException
 
@@ -119,9 +119,9 @@ class CachedRevisionInfo:
         snapshot_path (`Path`):
             Path to the revision directory in the `snapshots` folder. It contains the
             exact tree structure as the repo on the Hub.
-        files: (`FrozenSet[CachedFileInfo]`):
+        files: (`frozenset[CachedFileInfo]`):
             Set of [`~CachedFileInfo`] describing all files contained in the snapshot.
-        refs (`FrozenSet[str]`):
+        refs (`frozenset[str]`):
             Set of `refs` pointing to this revision. If the revision has no `refs`, it
             is considered detached.
             Example: `{"main", "2.4.0"}` or `{"refs/pr/1"}`.
@@ -149,8 +149,8 @@ class CachedRevisionInfo:
     commit_hash: str
     snapshot_path: Path
     size_on_disk: int
-    files: FrozenSet[CachedFileInfo]
-    refs: FrozenSet[str]
+    files: frozenset[CachedFileInfo]
+    refs: frozenset[str]
 
     last_modified: float
 
@@ -196,7 +196,7 @@ class CachedRepoInfo:
             Sum of the blob file sizes in the cached repo.
         nb_files (`int`):
             Total number of blob files in the cached repo.
-        revisions (`FrozenSet[CachedRevisionInfo]`):
+        revisions (`frozenset[CachedRevisionInfo]`):
             Set of [`~CachedRevisionInfo`] describing all revisions cached in the repo.
         last_accessed (`float`):
             Timestamp of the last time a blob file of the repo has been accessed.
@@ -225,7 +225,7 @@ class CachedRepoInfo:
     repo_path: Path
     size_on_disk: int
     nb_files: int
-    revisions: FrozenSet[CachedRevisionInfo]
+    revisions: frozenset[CachedRevisionInfo]
 
     last_accessed: float
     last_modified: float
@@ -260,7 +260,7 @@ class CachedRepoInfo:
         return _format_size(self.size_on_disk)
 
     @property
-    def refs(self) -> Dict[str, CachedRevisionInfo]:
+    def refs(self) -> dict[str, CachedRevisionInfo]:
         """
         (property) Mapping between `refs` and revision data structures.
         """
@@ -277,21 +277,21 @@ class DeleteCacheStrategy:
     Args:
         expected_freed_size (`float`):
             Expected freed size once strategy is executed.
-        blobs (`FrozenSet[Path]`):
+        blobs (`frozenset[Path]`):
             Set of blob file paths to be deleted.
-        refs (`FrozenSet[Path]`):
+        refs (`frozenset[Path]`):
             Set of reference file paths to be deleted.
-        repos (`FrozenSet[Path]`):
+        repos (`frozenset[Path]`):
             Set of entire repo paths to be deleted.
-        snapshots (`FrozenSet[Path]`):
+        snapshots (`frozenset[Path]`):
             Set of snapshots to be deleted (directory of symlinks).
     """
 
     expected_freed_size: int
-    blobs: FrozenSet[Path]
-    refs: FrozenSet[Path]
-    repos: FrozenSet[Path]
-    snapshots: FrozenSet[Path]
+    blobs: frozenset[Path]
+    refs: frozenset[Path]
+    repos: frozenset[Path]
+    snapshots: frozenset[Path]
 
     @property
     def expected_freed_size_str(self) -> str:
@@ -352,10 +352,10 @@ class HFCacheInfo:
     Args:
         size_on_disk (`int`):
             Sum of all valid repo sizes in the cache-system.
-        repos (`FrozenSet[CachedRepoInfo]`):
+        repos (`frozenset[CachedRepoInfo]`):
             Set of [`~CachedRepoInfo`] describing all valid cached repos found on the
             cache-system while scanning.
-        warnings (`List[CorruptedCacheException]`):
+        warnings (`list[CorruptedCacheException]`):
             List of [`~CorruptedCacheException`] that occurred while scanning the cache.
             Those exceptions are captured so that the scan can continue. Corrupted repos
             are skipped from the scan.
@@ -369,8 +369,8 @@ class HFCacheInfo:
     """
 
     size_on_disk: int
-    repos: FrozenSet[CachedRepoInfo]
-    warnings: List[CorruptedCacheException]
+    repos: frozenset[CachedRepoInfo]
+    warnings: list[CorruptedCacheException]
 
     @property
     def size_on_disk_str(self) -> str:
@@ -420,9 +420,9 @@ class HFCacheInfo:
 
         </Tip>
         """
-        hashes_to_delete: Set[str] = set(revisions)
+        hashes_to_delete: set[str] = set(revisions)
 
-        repos_with_revisions: Dict[CachedRepoInfo, Set[CachedRevisionInfo]] = defaultdict(set)
+        repos_with_revisions: dict[CachedRepoInfo, set[CachedRevisionInfo]] = defaultdict(set)
 
         for repo in self.repos:
             for revision in repo.revisions:
@@ -433,10 +433,10 @@ class HFCacheInfo:
         if len(hashes_to_delete) > 0:
             logger.warning(f"Revision(s) not found - cannot delete them: {', '.join(hashes_to_delete)}")
 
-        delete_strategy_blobs: Set[Path] = set()
-        delete_strategy_refs: Set[Path] = set()
-        delete_strategy_repos: Set[Path] = set()
-        delete_strategy_snapshots: Set[Path] = set()
+        delete_strategy_blobs: set[Path] = set()
+        delete_strategy_refs: set[Path] = set()
+        delete_strategy_repos: set[Path] = set()
+        delete_strategy_snapshots: set[Path] = set()
         delete_strategy_expected_freed_size = 0
 
         for affected_repo, revisions_to_delete in repos_with_revisions.items():
@@ -681,8 +681,8 @@ def scan_cache_dir(cache_dir: Optional[Union[str, Path]] = None) -> HFCacheInfo:
             f"Scan cache expects a directory but found a file: {cache_dir}. Please use `cache_dir` argument or set `HF_HUB_CACHE` environment variable."
         )
 
-    repos: Set[CachedRepoInfo] = set()
-    warnings: List[CorruptedCacheException] = []
+    repos: set[CachedRepoInfo] = set()
+    warnings: list[CorruptedCacheException] = []
     for repo_path in cache_dir.iterdir():
         if repo_path.name == ".locks":  # skip './.locks/' folder
             continue
@@ -718,7 +718,7 @@ def _scan_cached_repo(repo_path: Path) -> CachedRepoInfo:
             f"Repo type must be `dataset`, `model` or `space`, found `{repo_type}` ({repo_path})."
         )
 
-    blob_stats: Dict[Path, os.stat_result] = {}  # Key is blob_path, value is blob stats
+    blob_stats: dict[Path, os.stat_result] = {}  # Key is blob_path, value is blob stats
 
     snapshots_path = repo_path / "snapshots"
     refs_path = repo_path / "refs"
@@ -729,7 +729,7 @@ def _scan_cached_repo(repo_path: Path) -> CachedRepoInfo:
     # Scan over `refs` directory
 
     # key is revision hash, value is set of refs
-    refs_by_hash: Dict[str, Set[str]] = defaultdict(set)
+    refs_by_hash: dict[str, set[str]] = defaultdict(set)
     if refs_path.exists():
         # Example of `refs` directory
         # ── refs
@@ -752,7 +752,7 @@ def _scan_cached_repo(repo_path: Path) -> CachedRepoInfo:
             refs_by_hash[commit_hash].add(ref_name)
 
     # Scan snapshots directory
-    cached_revisions: Set[CachedRevisionInfo] = set()
+    cached_revisions: set[CachedRevisionInfo] = set()
     for revision_path in snapshots_path.iterdir():
         # Ignore OS-created helper files
         if revision_path.name in FILES_TO_IGNORE:

huggingface_hub/utils/_deprecation.py

@@ -62,7 +62,7 @@ def _deprecate_arguments(
     Args:
         version (`str`):
             The version when deprecated arguments will result in error.
-        deprecated_args (`List[str]`):
+        deprecated_args (`list[str]`):
             List of the arguments to be deprecated.
         custom_message (`str`, *optional*):
             Warning message that is raised. If not passed, a default warning message

huggingface_hub/utils/_dotenv.py

@@ -1,28 +1,28 @@
 # AI-generated module (ChatGPT)
 import re
-from typing import Dict
+from typing import Optional
 
 
-def load_dotenv(dotenv_str: str) -> Dict[str, str]:
+def load_dotenv(dotenv_str: str, environ: Optional[dict[str, str]] = None) -> dict[str, str]:
     """
     Parse a DOTENV-format string and return a dictionary of key-value pairs.
     Handles quoted values, comments, export keyword, and blank lines.
     """
-    env: Dict[str, str] = {}
+    env: dict[str, str] = {}
     line_pattern = re.compile(
         r"""
         ^\s*
-        (?:export\s+)?                    # optional export
+        (?:export[^\S\n]+)?               # optional export
         ([A-Za-z_][A-Za-z0-9_]*)          # key
-        \s*=\s*
+        [^\S\n]*(=)?[^\S\n]*
         (                                 # value group
             (?:
                 '(?:\\'|[^'])*'           # single-quoted value
-                | "(?:\\"|[^"])*"         # double-quoted value
+                | \"(?:\\\"|[^\"])*\"     # double-quoted value
                 | [^#\n\r]+?              # unquoted value
             )
         )?
-        \s*(?:\#.*)?$                     # optional inline comment
+        [^\S\n]*(?:\#.*)?$                # optional inline comment
     """,
         re.VERBOSE,
     )
@@ -33,19 +33,23 @@ def load_dotenv(dotenv_str: str) -> Dict[str, str]:
             continue  # Skip comments and empty lines
 
         match = line_pattern.match(line)
-        if not match:
-            continue  # Skip malformed lines
-
-        key, raw_val = match.group(1), match.group(2) or ""
-        val = raw_val.strip()
-
-        # Remove surrounding quotes if quoted
-        if (val.startswith('"') and val.endswith('"')) or (val.startswith("'") and val.endswith("'")):
-            val = val[1:-1]
-            val = val.replace(r"\n", "\n").replace(r"\t", "\t").replace(r"\"", '"').replace(r"\\", "\\")
-            if raw_val.startswith('"'):
-                val = val.replace(r"\$", "$")  # only in double quotes
-
-        env[key] = val
+        if match:
+            key = match.group(1)
+            val = None
+            if match.group(2):  # if there is '='
+                raw_val = match.group(3) or ""
+                val = raw_val.strip()
+                # Remove surrounding quotes if quoted
+                if (val.startswith('"') and val.endswith('"')) or (val.startswith("'") and val.endswith("'")):
+                    val = val[1:-1]
+                    val = val.replace(r"\n", "\n").replace(r"\t", "\t").replace(r"\"", '"').replace(r"\\", "\\")
+                    if raw_val.startswith('"'):
+                        val = val.replace(r"\$", "$")  # only in double quotes
+            elif environ is not None:
+                # Get it from the current environment
+                val = environ.get(key)
+
+            if val is not None:
+                env[key] = val
 
     return env

huggingface_hub/utils/_fixes.py

@@ -1,13 +1,3 @@
-# JSONDecodeError was introduced in requests=2.27 released in 2022.
-# This allows us to support older requests for users
-# More information: https://github.com/psf/requests/pull/5856
-try:
-    from requests import JSONDecodeError  # type: ignore  # noqa: F401
-except ImportError:
-    try:
-        from simplejson import JSONDecodeError  # type: ignore # noqa: F401
-    except ImportError:
-        from json import JSONDecodeError  # type: ignore  # noqa: F401
 import contextlib
 import os
 import shutil

huggingface_hub/utils/_git_credential.py

@@ -16,7 +16,7 @@
 
 import re
 import subprocess
-from typing import List, Optional
+from typing import Optional
 
 from ..constants import ENDPOINT
 from ._subprocess import run_interactive_subprocess, run_subprocess
@@ -27,14 +27,14 @@ GIT_CREDENTIAL_REGEX = re.compile(
         ^\s* # start of line
         credential\.helper # credential.helper value
         \s*=\s* # separator
-        (\w+) # the helper name (group 1)
+        ([\w\-\/]+) # the helper name or absolute path (group 1)
         (\s|$) # whitespace or end of line
     """,
     flags=re.MULTILINE | re.IGNORECASE | re.VERBOSE,
 )
 
 
-def list_credential_helpers(folder: Optional[str] = None) -> List[str]:
+def list_credential_helpers(folder: Optional[str] = None) -> list[str]:
     """Return the list of git credential helpers configured.
 
     See https://git-scm.com/docs/gitcredentials.
@@ -104,7 +104,7 @@ def unset_git_credential(username: str = "hf_user", folder: Optional[str] = None
         stdin.flush()
 
 
-def _parse_credential_output(output: str) -> List[str]:
+def _parse_credential_output(output: str) -> list[str]:
     """Parse the output of `git credential fill` to extract the password.
 
     Args: