huggingface-hub 0.32.1__py3-none-any.whl → 0.32.3__py3-none-any.whl

huggingface_hub/__init__.py

@@ -46,7 +46,7 @@ import sys
 from typing import TYPE_CHECKING
 
 
-__version__ = "0.32.1"
+__version__ = "0.32.3"
 
 # Alphabetical order of definitions is ensured in tests
 # WARNING: any comment added in this dictionary definition will be lost when

huggingface_hub/_snapshot_download.py

@@ -1,6 +1,6 @@
 import os
 from pathlib import Path
-from typing import Dict, List, Literal, Optional, Union
+from typing import Dict, Iterable, List, Literal, Optional, Union
 
 import requests
 from tqdm.auto import tqdm as base_tqdm
@@ -15,13 +15,15 @@ from .errors import (
     RevisionNotFoundError,
 )
 from .file_download import REGEX_COMMIT_HASH, hf_hub_download, repo_folder_name
-from .hf_api import DatasetInfo, HfApi, ModelInfo, SpaceInfo
+from .hf_api import DatasetInfo, HfApi, ModelInfo, RepoFile, SpaceInfo
 from .utils import OfflineModeIsEnabled, filter_repo_objects, logging, validate_hf_hub_args
 from .utils import tqdm as hf_tqdm
 
 
 logger = logging.get_logger(__name__)
 
+VERY_LARGE_REPO_THRESHOLD = 50000  # After this limit, we don't consider `repo_info.siblings` to be reliable enough
+
 
 @validate_hf_hub_args
 def snapshot_download(
@@ -145,20 +147,22 @@ def snapshot_download(
 
     storage_folder = os.path.join(cache_dir, repo_folder_name(repo_id=repo_id, repo_type=repo_type))
 
+    api = HfApi(
+        library_name=library_name,
+        library_version=library_version,
+        user_agent=user_agent,
+        endpoint=endpoint,
+        headers=headers,
+        token=token,
+    )
+
     repo_info: Union[ModelInfo, DatasetInfo, SpaceInfo, None] = None
     api_call_error: Optional[Exception] = None
     if not local_files_only:
         # try/except logic to handle different errors => taken from `hf_hub_download`
         try:
             # if we have internet connection we want to list files to download
-            api = HfApi(
-                library_name=library_name,
-                library_version=library_version,
-                user_agent=user_agent,
-                endpoint=endpoint,
-                headers=headers,
-            )
-            repo_info = api.repo_info(repo_id=repo_id, repo_type=repo_type, revision=revision, token=token)
+            repo_info = api.repo_info(repo_id=repo_id, repo_type=repo_type, revision=revision)
         except (requests.exceptions.SSLError, requests.exceptions.ProxyError):
             # Actually raise for those subclasses of ConnectionError
             raise
@@ -251,13 +255,31 @@ def snapshot_download(
     # => let's download the files!
     assert repo_info.sha is not None, "Repo info returned from server must have a revision sha."
     assert repo_info.siblings is not None, "Repo info returned from server must have a siblings list."
-    filtered_repo_files = list(
-        filter_repo_objects(
-            items=[f.rfilename for f in repo_info.siblings],
-            allow_patterns=allow_patterns,
-            ignore_patterns=ignore_patterns,
+
+    # Corner case: on very large repos, the siblings list in `repo_info` might not contain all files.
+    # In that case, we need to use the `list_repo_tree` method to prevent caching issues.
+    repo_files: Iterable[str] = [f.rfilename for f in repo_info.siblings]
+    has_many_files = len(repo_info.siblings) > VERY_LARGE_REPO_THRESHOLD
+    if has_many_files:
+        logger.info("The repo has more than 50,000 files. Using `list_repo_tree` to ensure all files are listed.")
+        repo_files = (
+            f.rfilename
+            for f in api.list_repo_tree(repo_id=repo_id, recursive=True, revision=revision, repo_type=repo_type)
+            if isinstance(f, RepoFile)
         )
+
+    filtered_repo_files: Iterable[str] = filter_repo_objects(
+        items=repo_files,
+        allow_patterns=allow_patterns,
+        ignore_patterns=ignore_patterns,
     )
+
+    if not has_many_files:
+        filtered_repo_files = list(filtered_repo_files)
+        tqdm_desc = f"Fetching {len(filtered_repo_files)} files"
+    else:
+        tqdm_desc = "Fetching ... files"
+
     commit_hash = repo_info.sha
     snapshot_folder = os.path.join(storage_folder, "snapshots", commit_hash)
     # if passed revision is not identical to commit_hash
@@ -305,7 +327,7 @@ def snapshot_download(
         thread_map(
             _inner_hf_hub_download,
             filtered_repo_files,
-            desc=f"Fetching {len(filtered_repo_files)} files",
+            desc=tqdm_desc,
             max_workers=max_workers,
             # User can use its own tqdm class or the default one from `huggingface_hub.utils`
             tqdm_class=tqdm_class or hf_tqdm,

huggingface_hub/inference/_mcp/_cli_hacks.py

@@ -0,0 +1,87 @@
+import asyncio
+import sys
+from functools import partial
+
+import typer
+
+
+def _patch_anyio_open_process():
+    """
+    Patch anyio.open_process to allow detached processes on Windows and Unix-like systems.
+
+    This is necessary to prevent the MCP client from being interrupted by Ctrl+C when running in the CLI.
+    """
+    import subprocess
+
+    import anyio
+
+    if getattr(anyio, "_tiny_agents_patched", False):
+        return
+    anyio._tiny_agents_patched = True
+
+    original_open_process = anyio.open_process
+
+    if sys.platform == "win32":
+        # On Windows, we need to set the creation flags to create a new process group
+
+        async def open_process_in_new_group(*args, **kwargs):
+            """
+            Wrapper for open_process to handle Windows-specific process creation flags.
+            """
+            # Ensure we pass the creation flags for Windows
+            kwargs.setdefault("creationflags", subprocess.CREATE_NEW_PROCESS_GROUP)
+            return await original_open_process(*args, **kwargs)
+
+        anyio.open_process = open_process_in_new_group
+    else:
+        # For Unix-like systems, we can use setsid to create a new session
+        async def open_process_in_new_group(*args, **kwargs):
+            """
+            Wrapper for open_process to handle Unix-like systems with start_new_session=True.
+            """
+            kwargs.setdefault("start_new_session", True)
+            return await original_open_process(*args, **kwargs)
+
+        anyio.open_process = open_process_in_new_group
+
+
+async def _async_prompt(exit_event: asyncio.Event, prompt: str = "» ") -> str:
+    """
+    Asynchronous prompt function that reads input from stdin without blocking.
+
+    This function is designed to work in an asynchronous context, allowing the event loop to gracefully stop it (e.g. on Ctrl+C).
+
+    Alternatively, we could use https://github.com/vxgmichel/aioconsole but that would be an additional dependency.
+    """
+    loop = asyncio.get_event_loop()
+
+    if sys.platform == "win32":
+        # Windows: Use run_in_executor to avoid blocking the event loop
+        # Degraded solution: this is not ideal as user will have to CTRL+C once more to stop the prompt (and it'll not be graceful)
+        return await loop.run_in_executor(None, partial(typer.prompt, prompt, prompt_suffix=" "))
+    else:
+        # UNIX-like: Use loop.add_reader for non-blocking stdin read
+        future = loop.create_future()
+
+        def on_input():
+            line = sys.stdin.readline()
+            loop.remove_reader(sys.stdin)
+            future.set_result(line)
+
+        print(prompt, end=" ", flush=True)
+        loop.add_reader(sys.stdin, on_input)  # not supported on Windows
+
+        # Wait for user input or exit event
+        # Wait until either the user hits enter or exit_event is set
+        await asyncio.wait(
+            [future, exit_event.wait()],
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+
+        # Check which one has been triggered
+        if exit_event.is_set():
+            future.cancel()
+            return ""
+
+        line = await future
+        return line.strip()

huggingface_hub/inference/_mcp/agent.py

@@ -20,7 +20,7 @@ class Agent(MCPClient):
     </Tip>
 
     Args:
-        model (`str`):
+        model (`str`, *optional*):
             The model to run inference with. Can be a model id hosted on the Hugging Face Hub, e.g. `meta-llama/Meta-Llama-3-8B-Instruct`
             or a URL to a deployed Inference Endpoint or other local or remote endpoint.
         servers (`Iterable[Dict]`):
@@ -28,6 +28,8 @@ class Agent(MCPClient):
         provider (`str`, *optional*):
             Name of the provider to use for inference. Defaults to "auto" i.e. the first of the providers available for the model, sorted by the user's order in https://hf.co/settings/inference-providers.
             If model is a URL or `base_url` is passed, then `provider` is not used.
+        base_url (`str`, *optional*):
+            The base URL to run inference. Defaults to None.
         api_key (`str`, *optional*):
             Token to use for authentication. Will default to the locally Hugging Face saved token if not provided. You can also use your own provider API key to interact directly with the provider's service.
         prompt (`str`, *optional*):
@@ -37,13 +39,14 @@ class Agent(MCPClient):
     def __init__(
         self,
         *,
-        model: str,
+        model: Optional[str] = None,
         servers: Iterable[Dict],
         provider: Optional[PROVIDER_OR_POLICY_T] = None,
+        base_url: Optional[str] = None,
         api_key: Optional[str] = None,
         prompt: Optional[str] = None,
     ):
-        super().__init__(model=model, provider=provider, api_key=api_key)
+        super().__init__(model=model, provider=provider, base_url=base_url, api_key=api_key)
         self._servers_cfg = list(servers)
         self.messages: List[Union[Dict, ChatCompletionInputMessage]] = [
             {"role": "system", "content": prompt or DEFAULT_SYSTEM_PROMPT}

huggingface_hub/inference/_mcp/cli.py

@@ -1,12 +1,13 @@
 import asyncio
 import os
 import signal
-from functools import partial
+import traceback
 from typing import Any, Dict, List, Optional
 
 import typer
 from rich import print
 
+from ._cli_hacks import _async_prompt, _patch_anyio_open_process
 from .agent import Agent
 from .utils import _load_agent_config
 
@@ -24,11 +25,6 @@ run_cli = typer.Typer(
 app.add_typer(run_cli, name="run")
 
 
-async def _ainput(prompt: str = "» ") -> str:
-    loop = asyncio.get_running_loop()
-    return await loop.run_in_executor(None, partial(typer.prompt, prompt, prompt_suffix=" "))
-
-
 async def run_agent(
     agent_path: Optional[str],
 ) -> None:
@@ -40,11 +36,15 @@ async def run_agent(
             Path to a local folder containing an `agent.json` and optionally a custom `PROMPT.md` file or a built-in agent stored in a Hugging Face dataset.
 
     """
+    _patch_anyio_open_process()  # Hacky way to prevent stdio connections to be stopped by Ctrl+C
+
     config, prompt = _load_agent_config(agent_path)
 
+    inputs: List[Dict[str, Any]] = config.get("inputs", [])
     servers: List[Dict[str, Any]] = config.get("servers", [])
 
     abort_event = asyncio.Event()
+    exit_event = asyncio.Event()
     first_sigint = True
 
     loop = asyncio.get_running_loop()
@@ -59,8 +59,7 @@ async def run_agent(
             return
 
         print("\n[red]Exiting...[/red]", flush=True)
-
-        os._exit(130)
+        exit_event.set()
 
     try:
         sigint_registered_in_loop = False
@@ -70,9 +69,65 @@ async def run_agent(
         except (AttributeError, NotImplementedError):
             # Windows (or any loop that doesn't support it) : fall back to sync
             signal.signal(signal.SIGINT, lambda *_: _sigint_handler())
+
+        # Handle inputs (i.e. env variables injection)
+        if len(inputs) > 0:
+            print(
+                "[bold blue]Some initial inputs are required by the agent. "
+                "Please provide a value or leave empty to load from env.[/bold blue]"
+            )
+            for input_item in inputs:
+                input_id = input_item["id"]
+                description = input_item["description"]
+                env_special_value = "${input:" + input_id + "}"  # Special value to indicate env variable injection
+
+                # Check env variables that will use this input
+                input_vars = list(
+                    {
+                        key
+                        for server in servers
+                        for key, value in server.get("config", {}).get("env", {}).items()
+                        if value == env_special_value
+                    }
+                )
+
+                if not input_vars:
+                    print(f"[yellow]Input {input_id} defined in config but not used by any server.[/yellow]")
+                    continue
+
+                # Prompt user for input
+                print(
+                    f"[blue] • {input_id}[/blue]: {description}. (default: load from {', '.join(input_vars)}).",
+                    end=" ",
+                )
+                user_input = (await _async_prompt(exit_event=exit_event)).strip()
+                if exit_event.is_set():
+                    return
+
+                # Inject user input (or env variable) into servers' env
+                for server in servers:
+                    env = server.get("config", {}).get("env", {})
+                    for key, value in env.items():
+                        if value == env_special_value:
+                            if user_input:
+                                env[key] = user_input
+                            else:
+                                value_from_env = os.getenv(key, "")
+                                env[key] = value_from_env
+                                if value_from_env:
+                                    print(f"[green]Value successfully loaded from '{key}'[/green]")
+                                else:
+                                    print(
+                                        f"[yellow]No value found for '{key}' in environment variables. Continuing.[/yellow]"
+                                    )
+
+            print()
+
+        # Main agent loop
         async with Agent(
-            provider=config["provider"],
-            model=config["model"],
+            provider=config.get("provider"),
+            model=config.get("model"),
+            base_url=config.get("endpointUrl"),
             servers=servers,
             prompt=prompt,
         ) as agent:
@@ -84,8 +139,12 @@ async def run_agent(
             while True:
                 abort_event.clear()
 
+                # Check if we should exit
+                if exit_event.is_set():
+                    return
+
                 try:
-                    user_input = await _ainput()
+                    user_input = await _async_prompt(exit_event=exit_event)
                     first_sigint = True
                 except EOFError:
                     print("\n[red]EOF received, exiting.[/red]", flush=True)
@@ -101,6 +160,8 @@ async def run_agent(
                     async for chunk in agent.run(user_input, abort_event=abort_event):
                         if abort_event.is_set() and not first_sigint:
                             break
+                        if exit_event.is_set():
+                            return
 
                         if hasattr(chunk, "choices"):
                             delta = chunk.choices[0].delta
@@ -123,9 +184,15 @@ async def run_agent(
                     print()
 
                 except Exception as e:
-                    print(f"\n[bold red]Error during agent run: {e}[/bold red]", flush=True)
+                    tb_str = traceback.format_exc()
+                    print(f"\n[bold red]Error during agent run: {e}\n{tb_str}[/bold red]", flush=True)
                     first_sigint = True  # Allow graceful interrupt for the next command
 
+    except Exception as e:
+        tb_str = traceback.format_exc()
+        print(f"\n[bold red]An unexpected error occurred: {e}\n{tb_str}[/bold red]", flush=True)
+        raise e
+
     finally:
         if sigint_registered_in_loop:
             try:

huggingface_hub/inference/_mcp/mcp_client.py

@@ -69,6 +69,8 @@ class MCPClient:
         provider (`str`, *optional*):
             Name of the provider to use for inference. Defaults to "auto" i.e. the first of the providers available for the model, sorted by the user's order in https://hf.co/settings/inference-providers.
             If model is a URL or `base_url` is passed, then `provider` is not used.
+        base_url (`str`, *optional*):
+            The base URL to run inference. Defaults to None.
         api_key (`str`, `optional`):
             Token to use for authentication. Will default to the locally Hugging Face saved token if not provided. You can also use your own provider API key to interact directly with the provider's service.
     """
@@ -76,17 +78,25 @@ class MCPClient:
     def __init__(
         self,
         *,
-        model: str,
+        model: Optional[str] = None,
         provider: Optional[PROVIDER_OR_POLICY_T] = None,
+        base_url: Optional[str] = None,
         api_key: Optional[str] = None,
     ):
         # Initialize MCP sessions as a dictionary of ClientSession objects
         self.sessions: Dict[ToolName, "ClientSession"] = {}
         self.exit_stack = AsyncExitStack()
         self.available_tools: List[ChatCompletionInputTool] = []
-
-        # Initialize the AsyncInferenceClient
-        self.client = AsyncInferenceClient(model=model, provider=provider, api_key=api_key)
+        # To be able to send the model in the payload if `base_url` is provided
+        if model is None and base_url is None:
+            raise ValueError("At least one of `model` or `base_url` should be set in `MCPClient`.")
+        self.payload_model = model
+        self.client = AsyncInferenceClient(
+            model=None if base_url is not None else model,
+            provider=provider,
+            api_key=api_key,
+            base_url=base_url,
+        )
 
     async def __aenter__(self):
         """Enter the context manager"""
@@ -99,6 +109,11 @@ class MCPClient:
         await self.client.__aexit__(exc_type, exc_val, exc_tb)
         await self.cleanup()
 
+    async def cleanup(self):
+        """Clean up resources"""
+        await self.client.close()
+        await self.exit_stack.aclose()
+
     @overload
     async def add_mcp_server(self, type: Literal["stdio"], **params: Unpack[StdioServerParameters_T]): ...
 
@@ -244,6 +259,7 @@ class MCPClient:
 
         # Create the streaming request
         response = await self.client.chat.completions.create(
+            model=self.payload_model,
             messages=messages,
             tools=tools,
             tool_choice="auto",
@@ -275,11 +291,13 @@ class MCPClient:
                 for tool_call in delta.tool_calls:
                     # Aggregate chunks into tool calls
                     if tool_call.index not in final_tool_calls:
-                        if tool_call.function.arguments is None:  # Corner case (depends on provider)
+                        if (
+                            tool_call.function.arguments is None or tool_call.function.arguments == "{}"
+                        ):  # Corner case (depends on provider)
                             tool_call.function.arguments = ""
                         final_tool_calls[tool_call.index] = tool_call
 
-                    if tool_call.function.arguments:
+                    elif tool_call.function.arguments:
                         final_tool_calls[tool_call.index].function.arguments += tool_call.function.arguments
 
             # Optionally exit early if no tools in first chunks
@@ -316,7 +334,3 @@ class MCPClient:
             tool_message_as_obj = ChatCompletionInputMessage.parse_obj_as_instance(tool_message)
             messages.append(tool_message_as_obj)
             yield tool_message_as_obj
-
-    async def cleanup(self):
-        """Clean up resources"""
-        await self.exit_stack.aclose()

huggingface_hub/serialization/_torch.py

@@ -246,7 +246,7 @@ def save_torch_state_dict(
             shared_tensors_to_discard=shared_tensors_to_discard,
         )
     else:
-        from torch import save as save_file_fn  # type: ignore[assignment]
+        from torch import save as save_file_fn  # type: ignore[assignment, no-redef]
 
         logger.warning(
             "You are using unsafe serialization. Due to security reasons, it is recommended not to load "

{huggingface_hub-0.32.1.dist-info → huggingface_hub-0.32.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: huggingface-hub
-Version: 0.32.1
+Version: 0.32.3
 Summary: Client library to download and publish models, datasets and other repos on the huggingface.co hub
 Home-page: https://github.com/huggingface/huggingface_hub
 Author: Hugging Face, Inc.

{huggingface_hub-0.32.1.dist-info → huggingface_hub-0.32.3.dist-info}/RECORD

@@ -1,11 +1,11 @@
-huggingface_hub/__init__.py,sha256=MraPcpVeTtz7kvp75UQIcplF8NG871xwGxDI4QHg_Mg,50644
+huggingface_hub/__init__.py,sha256=cK2MmEMaR4mvhSeDsQFuY2MLlfw8A3lKZbrwTzs-V9E,50644
 huggingface_hub/_commit_api.py,sha256=ZbmuIhFdF8B3F_cvGtxorka7MmIQOk8oBkCtYltnCvI,39456
 huggingface_hub/_commit_scheduler.py,sha256=tfIoO1xWHjTJ6qy6VS6HIoymDycFPg0d6pBSZprrU2U,14679
 huggingface_hub/_inference_endpoints.py,sha256=qXR0utAYRaEWTI8EXzAsDpVDcYpp8bJPEBbcOxRS52E,17413
 huggingface_hub/_local_folder.py,sha256=7Uce_z51D7ZZ58GF7eUOtcq1cCuYQMOEF-W4p85iQTo,16885
 huggingface_hub/_login.py,sha256=ssf4viT5BhHI2ZidnSuAZcrwSxzaLOrf8xgRVKuvu_A,20298
 huggingface_hub/_oauth.py,sha256=YNbSSZCNZLiCqwMoYboSAfI3XjEsbyAADJcwgRAdhBc,18802
-huggingface_hub/_snapshot_download.py,sha256=RqhfsESBHwXAoZxVvw68W7vGhmXSbl7RoEFOPLvw3Ls,15186
+huggingface_hub/_snapshot_download.py,sha256=5BvLNm_1DgdBNXNWOP8omK-9unIyqNSVpDNmxfClxFk,16078
 huggingface_hub/_space_api.py,sha256=jb6rF8qLtjaNU12D-8ygAPM26xDiHCu8CHXHowhGTmg,5470
 huggingface_hub/_tensorboard_logger.py,sha256=ZkYcAUiRC8RGL214QUYtp58O8G5tn-HF6DCWha9imcA,8358
 huggingface_hub/_upload_large_folder.py,sha256=elY5Rv2YVJECVpdZ9PM1zdO8kG-jmi8DifLOa7aC3EU,24178
@@ -81,10 +81,11 @@ huggingface_hub/inference/_generated/types/zero_shot_classification.py,sha256=BA
 huggingface_hub/inference/_generated/types/zero_shot_image_classification.py,sha256=8J9n6VqFARkWvPfAZNWEG70AlrMGldU95EGQQwn06zI,1487
 huggingface_hub/inference/_generated/types/zero_shot_object_detection.py,sha256=GUd81LIV7oEbRWayDlAVgyLmY596r1M3AW0jXDp1yTA,1630
 huggingface_hub/inference/_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-huggingface_hub/inference/_mcp/agent.py,sha256=RDpqy2rcVKy0euIK43OAAczLlx0UH1QIACHMFjTItq0,4077
-huggingface_hub/inference/_mcp/cli.py,sha256=Pw6nZP57uzDWZGXRVCAqLHsLYO_WiQd4UPcQdXiCa-o,5557
+huggingface_hub/inference/_mcp/_cli_hacks.py,sha256=NP8xA-7-3kJIzLHg3FuHXdnpli89OAMPILPrTk60lwU,3131
+huggingface_hub/inference/_mcp/agent.py,sha256=azX9_lsFjNlgsEvRYdKgsmOmpNReWIcbuMeIVWc852k,4264
+huggingface_hub/inference/_mcp/cli.py,sha256=6WP2bqdfSj80IYdwnzwO4ilEb7PgghgctD4iLV4ydqg,8588
 huggingface_hub/inference/_mcp/constants.py,sha256=tE_V6qcvsmvVoJa4eg04jhoTR2Cx1cNHieY2ENrm1_M,2511
-huggingface_hub/inference/_mcp/mcp_client.py,sha256=MwoovV2UTf7F8rxxQucAd4WSnIiJ71wx09QCrXDrP0Q,13477
+huggingface_hub/inference/_mcp/mcp_client.py,sha256=yHfpfztIepARqD_3bFSFWOn402BWO1tptqlIVGR7zJk,14130
 huggingface_hub/inference/_mcp/utils.py,sha256=K7rr4FxCh9OYWwYNlnvQraNLy9y3z-5yVMBIaoCQMjA,4052
 huggingface_hub/inference/_providers/__init__.py,sha256=IrLTMERrbRuPiVdBQEMK9TMvXrsGId4-u2ucMkG-vTU,7671
 huggingface_hub/inference/_providers/_common.py,sha256=Octgz-PbHw62iW3Oa8rF7rxvBJR0ZmL4ouv3NoX-weE,10131
@@ -106,7 +107,7 @@ huggingface_hub/serialization/__init__.py,sha256=kn-Fa-m4FzMnN8lNsF-SwFcfzug4Cuc
 huggingface_hub/serialization/_base.py,sha256=Df3GwGR9NzeK_SD75prXLucJAzPiNPgHbgXSw-_LTk8,8126
 huggingface_hub/serialization/_dduf.py,sha256=s42239rLiHwaJE36QDEmS5GH7DSmQ__BffiHJO5RjIg,15424
 huggingface_hub/serialization/_tensorflow.py,sha256=zHOvEMg-JHC55Fm4roDT3LUCDO5zB9qtXZffG065RAM,3625
-huggingface_hub/serialization/_torch.py,sha256=hJglq5F56s3k06GfLuYKQV4bSSjXQLuk1CC9l1M3Fmo,45191
+huggingface_hub/serialization/_torch.py,sha256=jpBmuSZJymMpvLcDcMaNxDu_fE5VkY_pAVH8e8stYIo,45201
 huggingface_hub/templates/datasetcard_template.md,sha256=W-EMqR6wndbrnZorkVv56URWPG49l7MATGeI015kTvs,5503
 huggingface_hub/templates/modelcard_template.md,sha256=4AqArS3cqdtbit5Bo-DhjcnDFR-pza5hErLLTPM4Yuc,6870
 huggingface_hub/utils/__init__.py,sha256=ORfVkn5D0wuLIq12jjhTzn5_c4F8fRPxB7TG-iednuQ,3722
@@ -137,9 +138,9 @@ huggingface_hub/utils/insecure_hashlib.py,sha256=iAaepavFZ5Dhfa5n8KozRfQprKmvcjS
 huggingface_hub/utils/logging.py,sha256=0A8fF1yh3L9Ka_bCDX2ml4U5Ht0tY8Dr3JcbRvWFuwo,4909
 huggingface_hub/utils/sha.py,sha256=OFnNGCba0sNcT2gUwaVCJnldxlltrHHe0DS_PCpV3C4,2134
 huggingface_hub/utils/tqdm.py,sha256=xAKcyfnNHsZ7L09WuEM5Ew5-MDhiahLACbbN2zMmcLs,10671
-huggingface_hub-0.32.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-huggingface_hub-0.32.1.dist-info/METADATA,sha256=y3e9ulpqrSxlIWNwdsA0aXk-ZK9nVDChQ5fjApF_hNA,14777
-huggingface_hub-0.32.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-huggingface_hub-0.32.1.dist-info/entry_points.txt,sha256=uelw0-fu0kd-CxIuOsR1bsjLIFnAaMQ6AIqluJYDhQw,184
-huggingface_hub-0.32.1.dist-info/top_level.txt,sha256=8KzlQJAY4miUvjAssOAJodqKOw3harNzuiwGQ9qLSSk,16
-huggingface_hub-0.32.1.dist-info/RECORD,,
+huggingface_hub-0.32.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+huggingface_hub-0.32.3.dist-info/METADATA,sha256=YG4e05qfvJNzzMc6QTzFoDez-KfYpn3acXE_LmzpllY,14777
+huggingface_hub-0.32.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+huggingface_hub-0.32.3.dist-info/entry_points.txt,sha256=uelw0-fu0kd-CxIuOsR1bsjLIFnAaMQ6AIqluJYDhQw,184
+huggingface_hub-0.32.3.dist-info/top_level.txt,sha256=8KzlQJAY4miUvjAssOAJodqKOw3harNzuiwGQ9qLSSk,16
+huggingface_hub-0.32.3.dist-info/RECORD,,