Add files using upload-large-folder tool

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub-1.14.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/_hot_reload/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/_hot_reload/client.py

@@ -0,0 +1,130 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import json
+import time
+from collections import deque
+from collections.abc import Iterator
+from typing import Literal, TypedDict
+
+import httpx
+
+from ..utils._headers import build_hf_headers
+from ..utils._http import hf_raise_for_status
+from .sse_client import SSEClient
+from .types import ApiGetReloadEventSourceData, ApiGetReloadRequest
+
+
+HOT_RELOADING_PORT = 7887
+CLIENT_TIMEOUT = 20
+
+
+class MultiReplicaStreamWarning(TypedDict):
+    kind: Literal["warning"]
+    message: str
+
+
+class MultiReplicaStreamEvent(TypedDict):
+    kind: Literal["event"]
+    event: ApiGetReloadEventSourceData
+
+
+class MultiReplicaStreamReplicaHash(TypedDict):
+    kind: Literal["replicaHash"]
+    hash: str
+
+
+class MultiReplicaStreamFullMatch(TypedDict):
+    kind: Literal["fullMatch"]
+
+
+class ReloadClient:
+    def __init__(
+        self,
+        *,
+        host: str,
+        subdomain: str,
+        replica_hash: str,
+        token: str | None,
+    ):
+        base_host = host.replace(subdomain, f"{subdomain}--{HOT_RELOADING_PORT}")
+        self.replica_hash = replica_hash
+        self.client = httpx.Client(
+            base_url=f"{base_host}/--replicas/+{replica_hash}",
+            headers=build_hf_headers(token=token),
+            timeout=CLIENT_TIMEOUT,
+        )
+
+    def get_reload(self, reload_id: str) -> Iterator[ApiGetReloadEventSourceData] | int:
+        req = ApiGetReloadRequest(reloadId=reload_id)
+        with self.client.stream("POST", "/get-reload", json=req) as res:
+            if res.status_code != 200:
+                return res.status_code
+            hf_raise_for_status(res)
+            for event in SSEClient(res.iter_bytes()).events():
+                if event.event == "message":
+                    yield json.loads(event.data)
+        return None
+
+
+def multi_replica_reload_events(
+    commit_sha: str,
+    host: str,
+    subdomain: str,
+    replica_hashes: list[str],
+    token: str | None,
+    max_retries: int = 10,
+) -> Iterator[
+    MultiReplicaStreamWarning | MultiReplicaStreamEvent | MultiReplicaStreamReplicaHash | MultiReplicaStreamFullMatch
+]:
+    clients = [
+        ReloadClient(
+            host=host,
+            subdomain=subdomain,
+            replica_hash=hash,
+            token=token,
+        )
+        for hash in replica_hashes
+    ]
+
+    first_client_events: dict[int, ApiGetReloadEventSourceData] = {}
+    for client_index, client in enumerate(clients):
+        if len(clients) > 1:
+            yield {"kind": "replicaHash", "hash": client.replica_hash}
+
+        retries = 0
+        while isinstance((events := client.get_reload(commit_sha)), int):
+            if (retries := retries + 1) > max_retries:
+                raise Exception("Too many retries reached")
+            if (status_code := events) not in (200, 204):
+                raise Exception(f"Unexpected {status_code=} on `ReloadClient.get_reload`")
+            subject = "reloadId" if status_code == 204 else "replica"
+            yield {"kind": "warning", "message": f"Retrying on unexpected {subject} not found"}
+            time.sleep(2)
+
+        full_match = True
+        replay: deque[ApiGetReloadEventSourceData] = deque()
+        for event_index, event in enumerate(events):
+            if client_index == 0:
+                first_client_events[event_index] = event
+            elif full_match := full_match and first_client_events.get(event_index) == event:
+                replay.append(event)
+                continue
+            while replay:
+                yield {"kind": "event", "event": replay.popleft()}
+            yield {"kind": "event", "event": event}
+
+        if client_index > 0 and full_match:
+            yield {"kind": "fullMatch"}

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/_hot_reload/sse_client.py

@@ -0,0 +1,144 @@
+"""
+Vendored file: Server Side Events (SSE) client for Python.
+
+Source:
+- Author: Maxime Petazzoni <maxime.petazzoni@bulix.org>
+- Repository: https://github.com/mpetazzoni/sseclient
+- File: https://github.com/mpetazzoni/sseclient/blob/main/sseclient/__init__.py
+
+License:
+- Apache-2.0 (from upstream project)
+
+Provides a generator of SSE received through an existing HTTP response.
+"""
+
+import logging
+
+__author__ = 'Maxime Petazzoni <maxime.petazzoni@bulix.org>'
+__email__ = 'maxime.petazzoni@bulix.org'
+__all__ = ['SSEClient']
+
+_FIELD_SEPARATOR = ':'
+
+
+class SSEClient:
+    """Implementation of a SSE client.
+
+    See http://www.w3.org/TR/2009/WD-eventsource-20091029/ for the
+    specification.
+    """
+
+    def __init__(self, event_source, char_enc='utf-8'):
+        """Initialize the SSE client over an existing, ready to consume
+        event source.
+
+        The event source is expected to be a binary stream and have a close()
+        method. That would usually be something that implements
+        io.BinaryIOBase, like an httplib or urllib3 HTTPResponse object.
+        """
+        self._logger = logging.getLogger(self.__class__.__module__)
+        self._logger.debug('Initialized SSE client from event source %s',
+                           event_source)
+        self._event_source = event_source
+        self._char_enc = char_enc
+
+    def _read(self):
+        """Read the incoming event source stream and yield event chunks.
+
+        Unfortunately it is possible for some servers to decide to break an
+        event into multiple HTTP chunks in the response. It is thus necessary
+        to correctly stitch together consecutive response chunks and find the
+        SSE delimiter (empty new line) to yield full, correct event chunks."""
+        data = b''
+        for chunk in self._event_source:
+            for line in chunk.splitlines(True):
+                data += line
+                if data.endswith((b'\r\r', b'\n\n', b'\r\n\r\n')):
+                    yield data
+                    data = b''
+        if data:
+            yield data
+
+    def events(self):
+        for chunk in self._read():
+            event = Event()
+            # Split before decoding so splitlines() only uses \r and \n
+            for line in chunk.splitlines():
+                # Decode the line.
+                line = line.decode(self._char_enc)
+
+                # Lines starting with a separator are comments and are to be
+                # ignored.
+                if not line.strip() or line.startswith(_FIELD_SEPARATOR):
+                    continue
+
+                data = line.split(_FIELD_SEPARATOR, 1)
+                field = data[0]
+
+                # Ignore unknown fields.
+                if field not in event.__dict__:
+                    self._logger.debug('Saw invalid field %s while parsing '
+                                       'Server Side Event', field)
+                    continue
+
+                if len(data) > 1:
+                    # From the spec:
+                    # "If value starts with a single U+0020 SPACE character,
+                    # remove it from value."
+                    if data[1].startswith(' '):
+                        value = data[1][1:]
+                    else:
+                        value = data[1]
+                else:
+                    # If no value is present after the separator,
+                    # assume an empty value.
+                    value = ''
+
+                # The data field may come over multiple lines and their values
+                # are concatenated with each other.
+                if field == 'data':
+                    event.__dict__[field] += value + '\n'
+                else:
+                    event.__dict__[field] = value
+
+            # Events with no data are not dispatched.
+            if not event.data:
+                continue
+
+            # If the data field ends with a newline, remove it.
+            if event.data.endswith('\n'):
+                event.data = event.data[0:-1]
+
+            # Empty event names default to 'message'
+            event.event = event.event or 'message'
+
+            # Dispatch the event
+            self._logger.debug('Dispatching %s...', event)
+            yield event
+
+    def close(self):
+        """Manually close the event source stream."""
+        self._event_source.close()
+
+
+class Event:
+    """Representation of an event from the event stream."""
+
+    def __init__(self, id=None, event='message', data='', retry=None):
+        self.id = id
+        self.event = event
+        self.data = data
+        self.retry = retry
+
+    def __str__(self):
+        s = f'{self.event} event'
+        if self.id:
+            s += f' #{self.id}'
+        if self.data:
+            s += ', {} byte{}'.format(len(self.data),
+                                        's' if len(self.data) else '')
+        else:
+            s += ', no data'
+        if self.retry:
+            s += f', retry in {self.retry}ms'
+        return s

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/_hot_reload/types.py

@@ -0,0 +1,121 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from typing import Literal, TypedDict
+
+from typing_extensions import NotRequired
+
+
+class ReloadRegion(TypedDict):
+    startLine: int
+    startCol: int
+    endLine: int
+    endCol: int
+
+
+class ReloadOperationObject(TypedDict):
+    kind: Literal["add", "update", "delete"]
+    region: ReloadRegion
+    objectType: str
+    objectName: str
+
+
+class ReloadOperationRun(TypedDict):
+    kind: Literal["run"]
+    region: ReloadRegion
+    codeLines: str
+    stdout: NotRequired[str]
+    stderr: NotRequired[str]
+
+
+class ReloadOperationException(TypedDict):
+    kind: Literal["exception"]
+    region: ReloadRegion
+    traceback: str
+
+
+class ReloadOperationError(TypedDict):
+    kind: Literal["error"]
+    traceback: str
+
+
+class ReloadOperationUI(TypedDict):
+    kind: Literal["ui"]
+    updated: bool
+
+
+class ReloadOperationFile(TypedDict):
+    kind: Literal["file"]
+    created: bool
+
+
+class ApiCreateReloadRequest(TypedDict):
+    filepath: str
+    contents: str
+    reloadId: NotRequired[str]
+
+
+class ApiCreateReloadResponseSuccess(TypedDict):
+    status: Literal["created"]
+    reloadId: str
+
+
+class ApiCreateReloadResponseError(TypedDict):
+    status: Literal["alreadyReloading", "fileNotFound"]
+
+
+class ApiCreateReloadResponse(TypedDict):
+    res: ApiCreateReloadResponseError | ApiCreateReloadResponseSuccess
+
+
+class ApiGetReloadRequest(TypedDict):
+    reloadId: str
+
+
+class ApiGetReloadEventSourceData(TypedDict):
+    data: (
+        ReloadOperationError
+        | ReloadOperationException
+        | ReloadOperationObject
+        | ReloadOperationRun
+        | ReloadOperationUI
+        | ReloadOperationFile
+    )
+
+
+class ApiGetStatusRequest(TypedDict):
+    revision: str
+
+
+class ApiGetStatusResponse(TypedDict):
+    reloading: bool
+    uncommited: list[str]
+
+
+class ApiFetchContentsRequest(TypedDict):
+    filepath: str
+
+
+class ApiFetchContentsResponseError(TypedDict):
+    status: Literal["fileNotFound"]
+
+
+class ApiFetchContentsResponseSuccess(TypedDict):
+    status: Literal["ok"]
+    contents: str
+
+
+class ApiFetchContentsResponse(TypedDict):
+    res: ApiFetchContentsResponseError | ApiFetchContentsResponseSuccess

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/cli/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2025 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/cli/_cli_utils.py

@@ -0,0 +1,1208 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains CLI utilities (styling, helpers)."""
+
+import dataclasses
+import datetime
+import difflib
+import importlib.metadata
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+from collections.abc import Callable, Sequence
+from enum import Enum
+from pathlib import Path
+from typing import TYPE_CHECKING, Annotated, Any, Literal, TypeVar, Union, cast
+
+import click
+import typer
+from typer.core import TyperCommand, TyperGroup
+
+from huggingface_hub import Volume, __version__, constants
+from huggingface_hub.errors import CLIError
+from huggingface_hub.utils import (
+    get_session,
+    hf_raise_for_status,
+    installation_method,
+    logging,
+    tabulate,
+)
+from huggingface_hub.utils._dotenv import load_dotenv
+
+from ._output import OutputFormatWithAuto, out
+
+
+logger = logging.get_logger()
+
+# Arbitrary maximum length of a cell in a table output
+_MAX_CELL_LENGTH = 35
+
+# Arbitrary default limit for models/datasets/spaces list commands.
+REPO_LIST_DEFAULT_LIMIT = 30
+
+if TYPE_CHECKING:
+    from huggingface_hub.hf_api import HfApi
+
+
+def get_hf_api(token: str | None = None) -> "HfApi":
+    # Import here to avoid circular import
+    from huggingface_hub.hf_api import HfApi
+
+    return HfApi(token=token, library_name="huggingface-cli", library_version=__version__)
+
+
+#### TYPER UTILS
+
+CLI_REFERENCE_URL = "https://huggingface.co/docs/huggingface_hub/en/guides/cli"
+
+
+def generate_epilog(examples: list[str], docs_anchor: str | None = None) -> str:
+    """Generate an epilog with examples and a Learn More section.
+
+    Args:
+        examples: List of example commands (without the `$ ` prefix).
+        docs_anchor: Optional anchor for the docs URL (e.g., "#hf-download").
+
+    Returns:
+        Formatted epilog string.
+    """
+    docs_url = f"{CLI_REFERENCE_URL}{docs_anchor}" if docs_anchor else CLI_REFERENCE_URL
+    examples_str = "\n".join(f"  $ {ex}" for ex in examples)
+    return f"""\
+Examples
+{examples_str}
+
+Learn more
+  Use `hf <command> --help` for more information about a command.
+  Read the documentation at {docs_url}
+"""
+
+
+TOPIC_T = Literal["main", "help"] | str
+FallbackHandlerT = Callable[[list[str], set[str]], int | None]
+ExpandPropertyT = TypeVar("ExpandPropertyT", bound=str)
+
+
+def _format_epilog_no_indent(epilog: str | None, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+    """Write the epilog without indentation."""
+    if epilog:
+        formatter.write_paragraph()
+        for line in epilog.split("\n"):
+            formatter.write_text(line)
+
+
+_ALIAS_SPLIT = re.compile(r"\s*\|\s*")
+
+
+class HFCliTyperGroup(TyperGroup):
+    """
+    Typer Group that:
+    - lists commands alphabetically within sections.
+    - separates commands by topic (main, help, etc.).
+    - formats epilog without extra indentation.
+    - supports aliases via pipe-separated names (e.g. ``name="list | ls"``).
+    - consumes the global formatting flags (``--format``, ``--json``, ``-q`` / ``--quiet``)
+      anywhere in the args of a leaf command and applies them to ``out``, so leaf
+      commands don't need to declare these options themselves.
+    - rewrites ``spaces/user/repo`` to ``user/repo --type space`` for commands that accept ``--type``.
+    - enriches "No such option" / "No such command" errors with available options or commands.
+    """
+
+    def invoke(self, ctx: click.Context) -> None:
+        """Enrich unknown-option errors with available options or subcommands.
+
+        Catches `NoSuchOption` raised during subcommand `make_context()`
+        (option parsing).  For leaf commands (e.g. `hf repos create --test`)
+        we list the command's options; for groups (e.g. `hf cache --test`)
+        we list subcommands since groups have no user-facing options.
+        """
+        try:
+            return super().invoke(ctx)
+        except click.NoSuchOption as e:
+            if e.ctx is not None and e.ctx.command is not None:
+                cmd = e.ctx.command
+                if isinstance(cmd, click.Group):
+                    # Group has no user-facing options -> show subcommands instead
+                    items = [
+                        (name, sub.get_short_help_str(limit=80))
+                        for name in cmd.list_commands(e.ctx)
+                        if (sub := cmd.get_command(e.ctx, name)) is not None and not sub.hidden
+                    ]
+                    _enrich_usage_error(e, "commands", items)
+                else:
+                    # Leaf command -> show its options using Click's rich formatting
+                    items = [
+                        record
+                        for p in cmd.get_params(e.ctx)
+                        if isinstance(p, click.Option) and not p.hidden and (record := p.get_help_record(e.ctx))
+                    ]
+                    _enrich_usage_error(e, "options", items)
+            raise
+
+    def resolve_command(self, ctx: click.Context, args: list[str]) -> tuple:
+        cmd_name = args[0] if args and not args[0].startswith("-") else None
+        cmd = self.get_command(ctx, cmd_name) if cmd_name else None
+
+        if cmd is not None:
+            self._rewrite_repo_type_prefix(cmd, args)
+
+        try:
+            name, resolved_cmd, sub_args = super().resolve_command(ctx, args)
+        except click.UsageError as e:
+            # Unknown subcommand -> add fuzzy suggestions and list available commands.
+            if cmd is None and cmd_name is not None:
+                # Expand aliases ("list | ls" → ["list", "ls"]) for accurate fuzzy matching.
+                visible_names = [
+                    alias
+                    for key, registered in self.commands.items()
+                    if not registered.hidden
+                    for alias in _ALIAS_SPLIT.split(key)
+                ]
+                matches = difflib.get_close_matches(cmd_name, visible_names)
+                if matches:
+                    suggestions = ", ".join(f"'{m}'" for m in matches)
+                    e.message = f"{e.message.rstrip('.')}. Did you mean {suggestions}?"
+                items = [
+                    (name, sub.get_short_help_str(limit=80))
+                    for name in self.list_commands(ctx)
+                    if (sub := self.get_command(ctx, name)) is not None and not sub.hidden
+                ]
+                _enrich_usage_error(e, "commands", items)
+            raise
+
+        # If we just resolved a leaf command, eagerly consume any global formatting
+        # flags (--format / --json / -q / --quiet) from its args before click parses
+        # them.  Group resolution is recursive — leaves (and only leaves) need this.
+        if resolved_cmd is not None and not isinstance(resolved_cmd, click.Group):
+            _consume_format_flags_for_leaf(resolved_cmd, sub_args)
+
+        return name, resolved_cmd, sub_args
+
+    @staticmethod
+    def _rewrite_repo_type_prefix(cmd: click.Command, args: list[str]) -> None:
+        """Rewrite prefixed repo IDs (e.g. ``spaces/user/repo``) to ``user/repo --type space``.
+
+        Only applies to commands that have a ``--type`` / ``--repo-type`` option and
+        at least one repo-ID positional argument (any ``click.Argument`` whose name
+        ends with ``_id``, e.g. ``repo_id``, ``from_id``, ``to_id``).  When the
+        token that maps to such an argument matches ``{prefix}/org/repo`` (where
+        *prefix* is one of ``spaces``, ``datasets``, or ``models``), the prefix is
+        stripped and an implicit ``--type {type}`` is appended.  An error is raised
+        if ``--type`` is also provided explicitly or if multiple prefixed arguments
+        disagree on the repo type.
+
+        Only repo-ID positional slots are inspected so that other positional
+        arguments (filenames, local paths, patterns …) are never misinterpreted as
+        prefixed repo IDs.
+        """
+        has_type_option = any(isinstance(param, click.Option) and "--type" in param.opts for param in cmd.params)
+        if not has_type_option:
+            return
+
+        # Locate all repo-ID positional arguments and their indices among Arguments.
+        repo_id_positions: set[int] = set()
+        arg_idx = 0
+        for param in cmd.params:
+            if isinstance(param, click.Argument):
+                if param.name in ("repo_id", "from_id", "to_id"):
+                    repo_id_positions.add(arg_idx)
+                arg_idx += 1
+
+        if not repo_id_positions:
+            return
+
+        # Build a set of option names that consume a following value token.
+        value_options: set[str] = set()
+        for param in cmd.params:
+            if isinstance(param, click.Option) and not param.is_flag:
+                for opt in (*param.opts, *param.secondary_opts):
+                    value_options.add(opt)
+
+        # Walk through args (skipping args[0] = command name) to map positional
+        # slots to their indices in `args`.
+        positional_count = 0
+        repo_id_arg_indices: list[int] = []
+        i = 1
+        while i < len(args):
+            arg = args[i]
+            if arg == "--":
+                break  # everything after -- is positional literal; stop rewriting
+            if arg.startswith("-"):
+                if "=" in arg or arg not in value_options:
+                    i += 1  # flag or --opt=val — single token
+                else:
+                    i += 2  # value-taking option — skip the value too
+            else:
+                if positional_count in repo_id_positions:
+                    repo_id_arg_indices.append(i)
+                positional_count += 1
+                i += 1
+
+        if not repo_id_arg_indices:
+            return
+
+        # Check each repo-ID arg for a type prefix and collect rewrites.
+        inferred_type: str | None = None
+        first_prefix: str | None = None
+        rewrites: list[tuple[int, str]] = []  # (args index, new value without prefix)
+
+        for arg_index in repo_id_arg_indices:
+            parts = args[arg_index].split("/", 2)
+            if len(parts) != 3 or parts[0] not in constants.REPO_TYPES_MAPPING:
+                continue
+            prefix = parts[0]
+            mapped_type = constants.REPO_TYPES_MAPPING[prefix]
+            if inferred_type is not None and mapped_type != inferred_type:
+                raise click.UsageError(f"Conflicting repo type prefixes: '{first_prefix}/' and '{prefix}/'.")
+            inferred_type = mapped_type
+            first_prefix = prefix
+            rewrites.append((arg_index, f"{parts[1]}/{parts[2]}"))
+
+        if not rewrites:
+            return
+
+        # Error if --type / --repo-type was also provided explicitly.
+        if any(
+            arg == "--type" or arg.startswith("--type=") or arg == "--repo-type" or arg.startswith("--repo-type=")
+            for arg in args
+        ):
+            raise click.UsageError(
+                f"Ambiguous repo type: got prefix '{first_prefix}/' in repo ID and explicit --type. Use one or the other."
+            )
+
+        # Apply all rewrites and append --type once.
+        for arg_index, new_value in rewrites:
+            args[arg_index] = new_value
+        args.extend(["--type", inferred_type])  # type: ignore
+
+    def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
+        # Try exact match first
+        cmd = super().get_command(ctx, cmd_name)
+        if cmd is not None:
+            return cmd
+        # Fall back to alias lookup: check if cmd_name matches any alias
+        # taken from https://github.com/fastapi/typer/issues/132#issuecomment-2417492805
+        for registered_name, registered_cmd in self.commands.items():
+            aliases = _ALIAS_SPLIT.split(registered_name)
+            if cmd_name in aliases:
+                return registered_cmd
+        return None
+
+    def _alias_map(self) -> dict[str, list[str]]:
+        """Build a mapping from primary command name to its aliases (if any)."""
+        result: dict[str, list[str]] = {}
+        for registered_name in self.commands:
+            parts = _ALIAS_SPLIT.split(registered_name)
+            primary = parts[0]
+            result[primary] = parts[1:]
+        return result
+
+    def format_commands(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        topics: dict[str, list] = {}
+        alias_map = self._alias_map()
+
+        for name in self.list_commands(ctx):
+            cmd = self.get_command(ctx, name)
+            if cmd is None or cmd.hidden:
+                continue
+            help_text = cmd.get_short_help_str(limit=formatter.width)
+            aliases = alias_map.get(name, [])
+            if aliases:
+                help_text = f"{help_text} [alias: {', '.join(aliases)}]"
+            topic = getattr(cmd, "topic", "main")
+            topics.setdefault(topic, []).append((name, help_text))
+
+        with formatter.section("Main commands"):
+            formatter.write_dl(topics["main"])
+        for topic in sorted(topics.keys()):
+            if topic == "main":
+                continue
+            with formatter.section(f"{topic.capitalize()} commands"):
+                formatter.write_dl(topics[topic])
+
+    def format_epilog(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        # Collect only the first example from each command (to keep group help concise)
+        # Full examples are shown in individual subcommand help (e.g. `hf buckets sync --help`)
+        all_examples: list[str] = []
+        for name in self.list_commands(ctx):
+            cmd = self.get_command(ctx, name)
+            if cmd is None or cmd.hidden:
+                continue
+            cmd_examples = getattr(cmd, "examples", [])
+            if cmd_examples:
+                all_examples.append(cmd_examples[0])
+
+        if all_examples:
+            epilog = generate_epilog(all_examples)
+            _format_epilog_no_indent(epilog, ctx, formatter)
+        elif self.epilog:
+            _format_epilog_no_indent(self.epilog, ctx, formatter)
+
+    def list_commands(self, ctx: click.Context) -> list[str]:  # type: ignore[name-defined]
+        # For aliased commands ("list | ls"), use the primary name (first entry).
+        primary_names: list[str] = []
+        for name in self.commands:
+            primary = _ALIAS_SPLIT.split(name)[0]
+            primary_names.append(primary)
+        return sorted(primary_names)
+
+
+_FORMATTING_OPTIONS_HELP_RECORDS: list[tuple[str, str]] = [
+    (
+        "--format [auto|human|agent|json|quiet]",
+        "Output format. Defaults to 'auto' which picks 'agent' or 'human' based on the terminal.",
+    ),
+    ("--json", "JSON output. Equivalent to '--format json'."),
+    ("-q, --quiet", "Quiet output (one ID per line). Equivalent to '--format quiet'."),
+]
+
+
+def _format_formatting_options_section(formatter: click.HelpFormatter) -> None:
+    with formatter.section("Formatting options"):
+        formatter.write_dl(_FORMATTING_OPTIONS_HELP_RECORDS)
+
+
+def _has_local_formatting_option(cmd: click.Command) -> bool:
+    """Return True if the command defines its own --format, --json or --quiet / -q.
+
+    Used to skip the global formatting flag pre-processor and the duplicated "Formatting options" help section for
+    legacy commands like 'hf jobs ps' that have their own format/quiet options.
+    """
+    for param in cmd.params:
+        if not isinstance(param, click.Option):
+            continue
+        opts = (*param.opts, *param.secondary_opts)
+        if "--format" in opts or "--json" in opts or "--quiet" in opts or "-q" in opts:
+            return True
+    return False
+
+
+def _consume_format_flags_for_leaf(cmd: click.Command, args: list[str]) -> None:
+    """Apply global formatting flags from 'args' to a leaf command.
+
+    Two modes, depending on the command:
+
+    * **Pass-through commands** (ignore_unknown_options=True, e.g. 'hf extensions exec'):
+      args are forwarded verbatim to an external binary; we don't touch them.
+
+    * **Legacy commands with a local --format option** (e.g. 'hf jobs ps' whose '--format' accepts Go templates):
+      the global flags are rewritten in-place to the legacy form ('--json' → '--format json', '--quiet'/'-q' → '--format quiet'
+      when the cmd has no own '--quiet') so click can parse them locally. This preserves backwards compatibility with the previous shorthand behavior.
+
+    * **Modern commands** (no local format/quiet/json options): the flags '--format <value>' / '--json' / '--quiet' / '-q' are stripped from 'args' and applied to the singleton 'out'.
+
+    Raises click.UsageError if multiple conflicting flags are supplied (e.g. '--json' together with '--format table').
+    """
+    if cmd.context_settings.get("ignore_unknown_options"):
+        return
+
+    has_local_format = False
+    has_local_quiet = False
+    has_local_json = False
+    for param in cmd.params:
+        if not isinstance(param, click.Option):
+            continue
+        opts = (*param.opts, *param.secondary_opts)
+        if "--format" in opts:
+            has_local_format = True
+        if "--quiet" in opts or "-q" in opts:
+            has_local_quiet = True
+        if "--json" in opts:
+            has_local_json = True
+
+    if has_local_format:
+        _rewrite_legacy_shorthands(args, rewrite_json=not has_local_json, rewrite_quiet=not has_local_quiet)
+        return
+
+    # Strip --format/--json/-q/--quiet from 'args' and apply to 'out'
+    chosen_mode: OutputFormatWithAuto = OutputFormatWithAuto.auto
+    chosen_flag: str | None = None
+
+    def _check_conflict(new_flag: str) -> None:
+        # Reject any second formatting flag before parsing values, so the user gets
+        # a "mutually exclusive" error rather than e.g. an "invalid value" error
+        # from the second flag's argument.
+        if chosen_flag is not None:
+            raise click.UsageError(f"'{chosen_flag}' and '{new_flag}' are mutually exclusive.")
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "--":
+            break  # everything after '--' is a positional literal
+        if arg == "--format":
+            _check_conflict("--format")
+            if i + 1 >= len(args):
+                raise click.UsageError("Option '--format' requires a value.")
+            chosen_mode = _parse_format_value(args[i + 1])
+            chosen_flag = "--format"
+            del args[i : i + 2]  # --format value => 2 args removed
+            continue
+        if arg.startswith("--format="):
+            _check_conflict("--format")
+            chosen_mode = _parse_format_value(arg[len("--format=") :])
+            chosen_flag = "--format"
+            del args[i : i + 1]
+            continue
+        if arg == "--json":
+            _check_conflict("--json")
+            chosen_mode = OutputFormatWithAuto.json
+            chosen_flag = "--json"
+            del args[i : i + 1]
+            continue
+        if arg in ("-q", "--quiet"):
+            _check_conflict(arg)
+            chosen_mode = OutputFormatWithAuto.quiet
+            chosen_flag = arg
+            del args[i : i + 1]
+            continue
+        i += 1
+
+    out.set_mode(chosen_mode)
+
+
+def _rewrite_legacy_shorthands(args: list[str], *, rewrite_json: bool, rewrite_quiet: bool) -> None:
+    """Rewrite --json / -q / --quiet to --format ... for legacy commands.
+
+    Used for commands like 'hf jobs ps' that still own their '--format' option.
+    The rewrite lets users keep using the global shorthand while click parses
+    '--format <value>' locally.
+    """
+    has_format_in_args = any(arg == "--format" or arg.startswith("--format=") for arg in args)
+
+    if rewrite_json and "--json" in args:
+        if has_format_in_args:
+            raise click.UsageError("'--json' and '--format' are mutually exclusive.")
+        idx = args.index("--json")
+        args[idx : idx + 1] = ["--format", "json"]
+        has_format_in_args = True
+
+    if rewrite_quiet:
+        flag = "-q" if "-q" in args else ("--quiet" if "--quiet" in args else None)
+        if flag is not None:
+            if has_format_in_args:
+                raise click.UsageError(f"'{flag}' and '--format' are mutually exclusive.")
+            idx = args.index(flag)
+            args[idx : idx + 1] = ["--format", "quiet"]
+
+
+def _parse_format_value(value: str) -> "OutputFormatWithAuto":
+    try:
+        return OutputFormatWithAuto(value)
+    except ValueError:
+        valid = ", ".join(m.value for m in OutputFormatWithAuto)
+        raise click.UsageError(f"Invalid value for '--format': '{value}'. Valid values: {valid}.") from None
+
+
+def _enrich_usage_error(error: click.UsageError, label: str, items: list[tuple[str, str]]) -> None:
+    """Append a list of available options or commands to a usage error message."""
+    if not items or error.ctx is None or f"Available {label} for" in error.message:
+        return
+    cmd_path = error.ctx.command_path
+    lines = [f"\n\nAvailable {label} for '{cmd_path}':"]
+    for name, help_text in items:
+        lines.append(f"  {name:30s} {help_text}")
+    lines.append(f"\nRun '{cmd_path} --help' for full details.")
+    if isinstance(error, click.NoSuchOption) and error.possibilities:
+        lines.append(f"\nDid you mean: {', '.join(sorted(error.possibilities))}?")
+        error.possibilities = []
+    error.message += "\n".join(lines)
+
+
+def fallback_typer_group_factory(
+    fallback_handler: FallbackHandlerT,
+    extra_commands_provider: Callable[[], list[tuple[str, str]]] | None = None,
+) -> type[HFCliTyperGroup]:
+    """Return a Typer group class that runs a fallback handler before command resolution."""
+
+    class FallbackTyperGroup(HFCliTyperGroup):
+        def resolve_command(self, ctx: click.Context, args: list[str]) -> tuple:
+            fallback_exit_code = fallback_handler(args, set(self.commands.keys()))
+            if fallback_exit_code is not None:
+                raise SystemExit(fallback_exit_code)
+            return super().resolve_command(ctx, args)
+
+        def format_commands(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+            super().format_commands(ctx, formatter)
+            if extra_commands_provider is not None:
+                entries = extra_commands_provider()
+                if entries:
+                    with formatter.section("Extension commands"):
+                        formatter.write_dl(entries)
+
+    return FallbackTyperGroup
+
+
+def HFCliCommand(topic: TOPIC_T, examples: list[str] | None = None) -> type[TyperCommand]:
+    def format_epilog(self: click.Command, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        _format_epilog_no_indent(self.epilog, ctx, formatter)
+
+    def format_options(self: TyperCommand, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        TyperCommand.format_options(self, ctx, formatter)
+        # Skip the section for commands that define their own --format / --quiet / --json,
+        # or for pass-through commands that forward args to an external binary.
+        if _has_local_formatting_option(self):
+            return
+        if self.context_settings.get("ignore_unknown_options"):
+            return
+        _format_formatting_options_section(formatter)
+
+    def parse_args(self: click.Command, ctx: click.Context, args: list[str]) -> list[str]:
+        # Show help when a command with required arguments is invoked without any args
+        # (mirrors group behavior: `hf jobs` prints help, so `hf download` should too).
+        if not args and not ctx.resilient_parsing:
+            if any(isinstance(p, click.Argument) and p.required for p in self.params):
+                click.echo(ctx.get_help(), color=ctx.color)
+                ctx.exit()
+        return TyperCommand.parse_args(self, ctx, args)
+
+    return type(
+        f"TyperCommand{topic.capitalize()}",
+        (TyperCommand,),
+        {
+            "topic": topic,
+            "examples": examples or [],
+            "format_epilog": format_epilog,
+            "format_options": format_options,
+            "parse_args": parse_args,
+        },
+    )
+
+
+class HFCliApp(typer.Typer):
+    """Custom Typer app for Hugging Face CLI."""
+
+    def command(  # type: ignore
+        self,
+        name: str | None = None,
+        *,
+        topic: TOPIC_T = "main",
+        examples: list[str] | None = None,
+        context_settings: dict[str, Any] | None = None,
+        help: str | None = None,
+        epilog: str | None = None,
+        short_help: str | None = None,
+        options_metavar: str = "[OPTIONS]",
+        add_help_option: bool = True,
+        no_args_is_help: bool = False,
+        hidden: bool = False,
+        deprecated: bool = False,
+        rich_help_panel: str | None = None,
+    ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+        # Generate epilog from examples if not explicitly provided
+        if epilog is None and examples:
+            epilog = generate_epilog(examples)
+
+        def _inner(func: Callable[..., Any]) -> Callable[..., Any]:
+            return super(HFCliApp, self).command(
+                name,
+                cls=HFCliCommand(topic, examples),
+                context_settings=context_settings,
+                help=help,
+                epilog=epilog,
+                short_help=short_help,
+                options_metavar=options_metavar,
+                add_help_option=add_help_option,
+                no_args_is_help=no_args_is_help,
+                hidden=hidden,
+                deprecated=deprecated,
+                rich_help_panel=rich_help_panel,
+            )(func)
+
+        return _inner
+
+
+def typer_factory(help: str, epilog: str | None = None, cls: type[TyperGroup] | None = None) -> "HFCliApp":
+    """Create a Typer app with consistent settings.
+
+    Args:
+        help: Help text for the app.
+        epilog: Optional epilog text (use `generate_epilog` to create one).
+        cls: Optional Click group class to use (defaults to `HFCliTyperGroup`).
+
+    Returns:
+        A configured Typer app.
+    """
+    if cls is None:
+        cls = HFCliTyperGroup
+    return HFCliApp(
+        help=help,
+        epilog=epilog,
+        add_completion=True,
+        no_args_is_help=True,
+        cls=cls,
+        # Disable rich completely for consistent experience
+        rich_markup_mode=None,
+        rich_help_panel=None,
+        pretty_exceptions_enable=False,
+        # Disable TyperGroup's suggest_commands, it matches against raw aliased
+        # keys ("list | ls") leaking pipe syntax into user-facing messages.
+        # HFCliTyperGroup.resolve_command() handles suggestions with expanded names.
+        suggest_commands=False,
+        # Increase max content width for better readability
+        context_settings={
+            "max_content_width": 120,
+            "help_option_names": ["-h", "--help"],
+        },
+    )
+
+
+class RepoType(str, Enum):
+    model = "model"
+    dataset = "dataset"
+    space = "space"
+
+
+RepoIdArg = Annotated[
+    str,
+    typer.Argument(
+        help="The ID of the repo (e.g. `username/repo-name` or `spaces/username/repo-name`).",
+    ),
+]
+
+
+RepoTypeOpt = Annotated[
+    RepoType,
+    typer.Option(
+        "--type",
+        "--repo-type",
+        help="The type of repository (model, dataset, or space).",
+    ),
+]
+
+TokenOpt = Annotated[
+    str | None,
+    typer.Option(
+        help="A User Access Token generated from https://huggingface.co/settings/tokens.",
+    ),
+]
+
+PrivateOpt = Annotated[
+    bool | None,
+    typer.Option(
+        help="Whether to create a private repo if repo doesn't exist on the Hub. Ignored if the repo already exists.",
+    ),
+]
+
+RevisionOpt = Annotated[
+    str | None,
+    typer.Option(
+        help="Git revision id which can be a branch name, a tag, or a commit hash.",
+    ),
+]
+
+
+LimitOpt = Annotated[
+    int,
+    typer.Option(help="Limit the number of results."),
+]
+
+AuthorOpt = Annotated[
+    str | None,
+    typer.Option(help="Filter by author or organization."),
+]
+
+FilterOpt = Annotated[
+    list[str] | None,
+    typer.Option(help="Filter by tags (e.g. 'text-classification'). Can be used multiple times."),
+]
+
+SearchOpt = Annotated[
+    str | None,
+    typer.Option(help="Search query."),
+]
+
+
+# --- Env / Secrets shared options and parsing helpers (used by jobs, repos, etc.) ---
+
+EnvOpt = Annotated[
+    list[str] | None,
+    typer.Option(
+        "-e",
+        "--env",
+        help="Set environment variables. E.g. --env ENV=value",
+    ),
+]
+
+SecretsOpt = Annotated[
+    list[str] | None,
+    typer.Option(
+        "-s",
+        "--secrets",
+        help=(
+            "Set secret environment variables. E.g. --secrets SECRET=value"
+            " or `--secrets HF_TOKEN` to pass your Hugging Face token."
+        ),
+    ),
+]
+
+EnvFileOpt = Annotated[
+    str | None,
+    typer.Option(
+        "--env-file",
+        help="Read in a file of environment variables.",
+    ),
+]
+
+SecretsFileOpt = Annotated[
+    str | None,
+    typer.Option(
+        help="Read in a file of secret environment variables.",
+    ),
+]
+
+
+def _get_extended_environ() -> dict[str, str]:
+    """Return a copy of ``os.environ`` with the user's HF token injected (if available)."""
+    from huggingface_hub import get_token
+
+    extended_environ = os.environ.copy()
+    if (token := get_token()) is not None:
+        extended_environ["HF_TOKEN"] = token
+    return extended_environ
+
+
+def parse_env_map(
+    env: list[str] | None = None,
+    env_file: str | None = None,
+) -> dict[str, str | None]:
+    """Parse ``-e``/``--env``/``-s``/``--secrets`` and ``--env-file``/``--secrets-file`` CLI args into a dict.
+
+    Uses an extended environment that includes the user's HF token so that
+    bare ``--secrets HF_TOKEN`` resolves correctly.
+    """
+    extended_environ = _get_extended_environ()
+    env_map: dict[str, str | None] = {}
+    if env_file:
+        env_map.update(load_dotenv(Path(env_file).read_text(), environ=extended_environ))
+    for env_value in env or []:
+        env_map.update(load_dotenv(env_value, environ=extended_environ))
+    return env_map
+
+
+def env_map_to_key_value_list(env_map: dict[str, str | None]) -> list[dict[str, str]] | None:
+    """Convert an env/secrets dict to the ``[{"key": ..., "value": ...}]`` format used by the Hub API."""
+    if not env_map:
+        return None
+    return [{"key": k, "value": v or ""} for k, v in env_map.items()]
+
+
+VolumesOpt = Annotated[
+    list[str] | None,
+    typer.Option(
+        "-v",
+        "--volume",
+        help="Mount one or more volumes. Format: hf://[TYPE/]SOURCE:/MOUNT_PATH[:ro]. "
+        "TYPE is one of: models, datasets, spaces, buckets. "
+        "TYPE defaults to models if omitted. "
+        "models, datasets and spaces are always mounted read-only. buckets are read+write by default. "
+        "E.g. -v hf://org/m:/data or -v hf://datasets/org/ds:/data or -v hf://buckets/org/b:/mnt:ro",
+    ),
+]
+
+_HF_PREFIX = "hf://"
+_HF_VOLUME_TYPES = {
+    "models": constants.REPO_TYPE_MODEL,
+    "datasets": constants.REPO_TYPE_DATASET,
+    "spaces": constants.REPO_TYPE_SPACE,
+    "buckets": "bucket",
+}
+
+
+def parse_volumes(volumes: list[str] | None) -> "list[Volume] | None":
+    """Parse volume specs from CLI arguments.
+
+    Format: hf://[TYPE/]SOURCE[/PATH]:/MOUNT_PATH[:ro|:rw]
+    Where TYPE is one of: models, datasets, spaces, buckets (defaults to models if omitted).
+    SOURCE is the repo/bucket identifier (e.g. 'username/my-model').
+    PATH is an optional subfolder inside the repo/bucket.
+    MOUNT_PATH starts with '/'.
+    Optional ':ro' or ':rw' suffix for read-only or read-write.
+
+    Examples:
+        hf://my-org/my-model:/data                (model, implicit type)
+        hf://models/my-org/my-model:/data         (model, explicit type)
+        hf://datasets/my-org/my-dataset:/data:ro
+        hf://buckets/my-org/my-bucket:/mnt
+        hf://spaces/my-org/my-space:/app
+        hf://datasets/org/ds/train:/data          (with path inside repo)
+        hf://buckets/org/b/sub/dir:/mnt           (with path inside bucket)
+    """
+
+    if not volumes:
+        return None
+
+    result: list[Volume] = []
+    for raw_spec in volumes:
+        # Strip :ro/:rw suffix
+        spec = raw_spec
+        read_only = None
+        if spec.endswith(":ro"):
+            read_only = True
+            spec = spec[:-3]
+        elif spec.endswith(":rw"):
+            read_only = False
+            spec = spec[:-3]
+
+        # Validate hf:// prefix
+        if not spec.startswith(_HF_PREFIX):
+            raise CLIError(
+                f"Invalid volume format: '{raw_spec}'. Source must start with 'hf://'. "
+                f"Expected hf://[TYPE/]SOURCE:/MOUNT_PATH[:ro]. E.g. hf://org/m:/data"
+            )
+        spec = spec[len(_HF_PREFIX) :]
+
+        # Find the mount path: look for :/ pattern
+        colon_slash_idx = spec.find(":/")
+        if colon_slash_idx == -1:
+            raise CLIError(
+                f"Invalid volume format: '{raw_spec}'. Expected hf://[TYPE/]SOURCE:/MOUNT_PATH[:ro]. E.g. hf://org/m:/data"
+            )
+        source_part = spec[:colon_slash_idx]
+        mount_path = spec[colon_slash_idx + 1 :]
+
+        # Parse type from source_part (first segment before /)
+        # Then split remaining into source (namespace/name or name) and optional path.
+        slash_idx = source_part.find("/")
+        if slash_idx == -1:
+            # No slash: bare source like "gpt2" -> model type
+            vol_type_str = constants.REPO_TYPE_MODEL
+            source = source_part
+            path = None
+        else:
+            first_segment = source_part[:slash_idx]
+            if first_segment in _HF_VOLUME_TYPES:
+                vol_type_str = _HF_VOLUME_TYPES[first_segment]
+                remaining = source_part[slash_idx + 1 :]
+            else:
+                # First segment isn't a known type -> model type
+                vol_type_str = constants.REPO_TYPE_MODEL
+                remaining = source_part
+
+            # Split remaining into source (namespace/name) and optional path.
+            # Repo/bucket IDs are "namespace/name" (2 segments) or "name" (1 segment).
+            # Any extra segments are the path inside the repo/bucket.
+            parts = remaining.split("/", 2)
+            if len(parts) >= 3:
+                source = parts[0] + "/" + parts[1]
+                path = parts[2]
+            else:
+                source = remaining
+                path = None
+
+        result.append(
+            Volume(
+                type=vol_type_str,
+                source=source,
+                mount_path=mount_path,
+                read_only=read_only,
+                path=path,
+            )
+        )
+    return result
+
+
+class OutputFormat(str, Enum):
+    """Output format for CLI list commands."""
+
+    table = "table"
+    json = "json"
+
+
+FormatOpt = Annotated[
+    OutputFormat,
+    typer.Option(
+        help="Output format (table or json).",
+    ),
+]
+
+
+def _set_output_mode(value: OutputFormatWithAuto) -> OutputFormatWithAuto:
+    """Callback for the legacy FormatWithAutoOpt option type.
+
+    Most commands now rely on the global --format / --json / -q flags consumed by _consume_format_flags_for_leaf instead
+    of declaring FormatWithAutoOpt themselves.  This callback is kept for the rare cases where a command still wires
+    FormatWithAutoOpt explicitly.
+    """
+    out.set_mode(value)
+    return value
+
+
+FormatWithAutoOpt = Annotated[
+    OutputFormatWithAuto,
+    typer.Option(help="Output format.", callback=_set_output_mode),
+]
+
+QuietOpt = Annotated[
+    bool,
+    typer.Option("-q", "--quiet", help="Print only IDs (one per line)."),
+]
+
+
+def _to_header(name: str) -> str:
+    """Convert a camelCase or PascalCase string to SCREAMING_SNAKE_CASE to be used as table header."""
+    s = re.sub(r"([a-z])([A-Z])", r"\1_\2", name)
+    return s.upper()
+
+
+def _format_value(value: Any) -> str:
+    """Convert a value to string for terminal display."""
+    if not value:
+        return ""
+    if isinstance(value, bool):
+        return "✔" if value else ""
+    if isinstance(value, datetime.datetime):
+        return value.strftime("%Y-%m-%d")
+    if isinstance(value, str) and re.match(r"^\d{4}-\d{2}-\d{2}T", value):
+        return value[:10]
+    if isinstance(value, list):
+        return ", ".join(_format_value(v) for v in value)
+    elif isinstance(value, dict):
+        if "name" in value:  # Likely to be a user or org => print name
+            return str(value["name"])
+        # TODO: extend if needed
+        return json.dumps(value)
+    return str(value)
+
+
+def _format_cell(value: Any, max_len: int = _MAX_CELL_LENGTH) -> str:
+    """Format a value + truncate it for table display."""
+    cell = _format_value(value)
+    if len(cell) > max_len:
+        cell = cell[: max_len - 3] + "..."
+    return cell
+
+
+def print_as_table(
+    items: Sequence[dict[str, Any]],
+    headers: list[str],
+    row_fn: Callable[[dict[str, Any]], list[str]],
+    alignments: dict[str, str] | None = None,
+) -> None:
+    """Print items as a formatted table.
+
+    Args:
+        items: Sequence of dictionaries representing the items to display.
+        headers: List of column headers.
+        row_fn: Function that takes an item dict and returns a list of string values for each column.
+        alignments: Optional mapping of header name to "left" or "right". Defaults to "left".
+    """
+    if not items:
+        print("No results found.")
+        return
+    rows = cast(list[list[Union[str, int]]], [row_fn(item) for item in items])
+    screaming_headers = [_to_header(h) for h in headers]
+    # Remap alignments keys to screaming case to match tabulate headers
+    screaming_alignments = {_to_header(k): v for k, v in (alignments or {}).items()}
+    print(tabulate(rows, headers=screaming_headers, alignments=screaming_alignments))
+
+
+def print_list_output(
+    items: Sequence[dict[str, Any]],
+    format: OutputFormat,
+    quiet: bool,
+    id_key: str = "id",
+    headers: list[str] | None = None,
+    row_fn: Callable[[dict[str, Any]], list[str]] | None = None,
+    alignments: dict[str, str] | None = None,
+) -> None:
+    """Print list command output in the specified format.
+
+    Args:
+        items: Sequence of dictionaries representing the items to display.
+        format: Output format.
+        quiet: If True, print only IDs (one per line).
+        id_key: Key to use for extracting IDs in quiet mode.
+        headers: Optional list of column names for headers. If not provided, auto-detected from keys.
+        row_fn: Optional function to extract row values. If not provided, uses _format_cell on each column.
+        alignments: Optional mapping of header name to "left" or "right". Defaults to "left".
+    """
+    if quiet:
+        for item in items:
+            print(item[id_key])
+        return
+
+    if format == OutputFormat.json:
+        print(json.dumps(list(items), indent=2, default=str))
+        return
+
+    if headers is None:
+        all_columns = list(items[0].keys()) if items else [id_key]
+        headers = [col for col in all_columns if any(_format_cell(item.get(col)) for item in items)]
+
+    if row_fn is None:
+
+        def row_fn(item: dict[str, Any]) -> list[str]:
+            return [_format_cell(item.get(col)) for col in headers]  # type: ignore[union-attr]
+
+    print_as_table(items, headers=headers, row_fn=row_fn, alignments=alignments)
+
+
+def _serialize_value(v: object) -> object:
+    """Recursively serialize a value to be JSON-compatible."""
+    if isinstance(v, datetime.datetime):
+        return v.isoformat()
+    elif isinstance(v, dict):
+        return {key: _serialize_value(val) for key, val in v.items() if val is not None}
+    elif isinstance(v, list):
+        return [_serialize_value(item) for item in v]
+    return v
+
+
+def api_object_to_dict(info: Any) -> dict[str, Any]:
+    """Convert repo info dataclasses to json-serializable dicts."""
+    return {k: _serialize_value(v) for k, v in dataclasses.asdict(info).items() if v is not None}
+
+
+def make_expand_properties_parser(valid_properties: Sequence[ExpandPropertyT]):
+    """Create a callback to parse and validate comma-separated expand properties."""
+
+    def _parse_expand_properties(value: str | None) -> list[ExpandPropertyT] | None:
+        if value is None:
+            return None
+        properties = [p.strip() for p in value.split(",")]
+        for prop in properties:
+            if prop not in valid_properties:
+                raise typer.BadParameter(
+                    f"Invalid expand property: '{prop}'. Valid values are: {', '.join(valid_properties)}"
+                )
+        return [cast(ExpandPropertyT, prop) for prop in properties]
+
+    return _parse_expand_properties
+
+
+### PyPI VERSION CHECKER
+
+
+def check_cli_update(library: Literal["huggingface_hub", "transformers"]) -> None:
+    """
+    Check whether a newer version of a library is available on PyPI.
+
+    If a newer version is found, print a hint pointing at `hf update`.
+
+    If current version is a pre-release (e.g. `1.0.0.rc1`), or a dev version (e.g. `1.0.0.dev1`), no check is performed.
+    If `HF_HUB_DISABLE_UPDATE_CHECK` is set, the check is skipped entirely.
+
+    This function is called at the entry point of the CLI. It only performs the check once every 24 hours, and any error
+    during the check is caught and logged, to avoid breaking the CLI.
+
+    Args:
+        library: The library to check for updates. Currently supports "huggingface_hub" and "transformers".
+    """
+    try:
+        _check_cli_update(library)
+    except Exception:
+        # We don't want the CLI to fail on version checks, no matter the reason.
+        logger.debug("Error while checking for CLI update.", exc_info=True)
+
+
+def _check_cli_update(library: Literal["huggingface_hub", "transformers"]) -> None:
+    if constants.HF_HUB_DISABLE_UPDATE_CHECK:
+        return
+
+    current_version = importlib.metadata.version(library)
+
+    # Skip if current version is a pre-release or dev version
+    if any(tag in current_version for tag in ["rc", "dev"]):
+        return
+
+    # Skip if already checked in the last 24 hours
+    if os.path.exists(constants.CHECK_FOR_UPDATE_DONE_PATH):
+        mtime = os.path.getmtime(constants.CHECK_FOR_UPDATE_DONE_PATH)
+        if (time.time() - mtime) < 24 * 3600:
+            return
+
+    # Touch the file to mark that we did the check now
+    Path(constants.CHECK_FOR_UPDATE_DONE_PATH).parent.mkdir(parents=True, exist_ok=True)
+    Path(constants.CHECK_FOR_UPDATE_DONE_PATH).touch()
+
+    # Check latest version from PyPI
+    latest_version = _fetch_latest_pypi_version(library)
+    if latest_version is None or current_version == latest_version:
+        return
+
+    if library == "huggingface_hub":
+        update_command = _get_huggingface_hub_update_command()
+    else:
+        update_command = _get_transformers_update_command()
+
+    message = f"A new version of {library} ({latest_version}) is available! You are using version {current_version}."
+    if update_command is not None:
+        match library:
+            case "huggingface_hub":
+                message += "\nTo update, run: hf update"
+            case _:
+                message += f"\nTo update, run: {' '.join(update_command)}"
+    out.hint(message)
+
+
+def _fetch_latest_pypi_version(library: str) -> str | None:
+    """Fetch the latest version of a library from PyPI. Returns None if the request fails."""
+    try:
+        response = get_session().get(f"https://pypi.org/pypi/{library}/json", timeout=2)
+        hf_raise_for_status(response)
+        return response.json()["info"]["version"]
+    except Exception:
+        logger.debug("Error while fetching latest version from PyPI.", exc_info=True)
+        return None
+
+
+def run_update() -> int:
+    """Run the install-method-appropriate update command for the `hf` CLI.
+
+    Raises CLIError if the installation method can't be determined.
+    Returns the subprocess exit code on success/failure of the update itself.
+    """
+    cmd = _get_huggingface_hub_update_command()
+    if cmd is None:
+        raise CLIError(
+            "Cannot determine how to update huggingface_hub (unknown installation method). Please update manually."
+        )
+    return subprocess.call(cmd)
+
+
+def _get_huggingface_hub_update_command() -> list[str] | None:
+    """Return the command to update huggingface_hub as an argv list, or None if the installation method is unknown."""
+    match installation_method():
+        case "brew":
+            return ["brew", "upgrade", "hf"]
+        case "hf_installer" if os.name == "nt":
+            return ["powershell", "-NoProfile", "-Command", "iwr -useb https://hf.co/cli/install.ps1 | iex"]
+        case "hf_installer":
+            return ["bash", "-c", "curl -LsSf https://hf.co/cli/install.sh | bash -"]
+        case "pip":
+            return [sys.executable, "-m", "pip", "install", "-U", "huggingface_hub"]
+        case _:
+            return None
+
+
+def _get_transformers_update_command() -> list[str] | None:
+    """Return the command to update transformers as an argv list, or None if the installation method is unknown."""
+    match installation_method():
+        case "hf_installer" if os.name == "nt":
+            return [
+                "powershell",
+                "-NoProfile",
+                "-Command",
+                "iwr -useb https://hf.co/cli/install.ps1 | iex -WithTransformers",
+            ]
+        case "hf_installer":
+            return ["bash", "-c", "curl -LsSf https://hf.co/cli/install.sh | bash -s -- --with-transformers"]
+        case "pip":
+            return [sys.executable, "-m", "pip", "install", "-U", "transformers"]
+        case _:
+            return None

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/cli/_errors.py

@@ -0,0 +1,115 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""CLI error handling utilities."""
+
+import traceback
+from collections.abc import Callable
+
+from huggingface_hub.errors import (
+    BucketNotFoundError,
+    CLIError,
+    CLIExtensionInstallError,
+    EntryNotFoundError,
+    GatedRepoError,
+    HfHubHTTPError,
+    LocalTokenNotFoundError,
+    RemoteEntryNotFoundError,
+    RepositoryNotFoundError,
+    RevisionNotFoundError,
+)
+
+
+def _format_repo_not_found(error: RepositoryNotFoundError) -> str:
+    label = error.repo_type.capitalize() if error.repo_type else "Repository"
+    if error.repo_id:
+        msg = f"{label} '{error.repo_id}' not found."
+    else:
+        msg = f"{label} not found."
+    msg += " If the repo is private, make sure you are authenticated and your token has the required permissions."
+    return msg
+
+
+def _format_gated_repo(error: GatedRepoError) -> str:
+    label = error.repo_type if error.repo_type else "repository"
+    if error.repo_id:
+        return f"Access denied. {label.capitalize()} '{error.repo_id}' requires approval."
+    return f"Access denied. This {label} requires approval."
+
+
+def _format_bucket_not_found(error: BucketNotFoundError) -> str:
+    if error.bucket_id:
+        return f"Bucket '{error.bucket_id}' not found. If the bucket is private, make sure you are authenticated and your token has the required permissions."
+    return "Bucket not found. Check the bucket id (namespace/name). If the bucket is private, make sure you are authenticated and your token has the required permissions."
+
+
+def _format_entry_not_found(error: RemoteEntryNotFoundError) -> str:
+    label = error.repo_type if error.repo_type else "repository"
+    url = str(error.response.url) if error.response else None
+    if error.repo_id:
+        msg = f"File not found in {label} '{error.repo_id}'."
+    else:
+        msg = f"File not found in {label}."
+    if url:
+        msg += f"\nURL: {url}"
+    return msg
+
+
+def _format_revision_not_found(error: RevisionNotFoundError) -> str:
+    label = error.repo_type if error.repo_type else "repository"
+    if error.repo_id:
+        return f"Revision not found in {label} '{error.repo_id}'."
+    return f"Revision not found in {label}. Check the revision parameter."
+
+
+def _format_cli_error(error: CLIError) -> str:
+    """No traceback, just the error message."""
+    return str(error)
+
+
+def _format_cli_extension_install_error(error: CLIExtensionInstallError) -> str:
+    """Format a CLI extension installation error.
+
+    The error is likely to be a tricky subprocess error to investigate. In this specific case we want to format the
+    traceback of the root cause while keeping the "nicely formatted" error message of the CLIExtensionInstallError
+    as a 1-line message.
+    """
+    cause_tb = (
+        "".join(traceback.format_exception(type(error.__cause__), error.__cause__, error.__cause__.__traceback__))
+        if error.__cause__ is not None
+        else ""
+    )
+    return f"{cause_tb}\n{error}"
+
+
+CLI_ERROR_MAPPINGS: dict[type[Exception], Callable[..., str]] = {
+    # GatedRepoError must come before RepositoryNotFoundError (it's a subclass).
+    GatedRepoError: _format_gated_repo,
+    BucketNotFoundError: _format_bucket_not_found,
+    RepositoryNotFoundError: _format_repo_not_found,
+    RevisionNotFoundError: _format_revision_not_found,
+    LocalTokenNotFoundError: lambda _: "Not logged in. Run 'hf auth login' first.",
+    RemoteEntryNotFoundError: _format_entry_not_found,
+    EntryNotFoundError: lambda error: str(error),
+    HfHubHTTPError: lambda error: str(error),
+    ValueError: lambda error: f"Invalid value. {error}",
+    CLIExtensionInstallError: _format_cli_extension_install_error,
+    CLIError: _format_cli_error,
+}
+
+
+def format_known_exception(error: Exception) -> str | None:
+    for exc_type, formatter in CLI_ERROR_MAPPINGS.items():
+        if isinstance(error, exc_type):
+            return formatter(error)
+    return None

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/cli/_file_listing.py

@@ -0,0 +1,225 @@
+# Copyright 2026-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Shared helpers for listing files in buckets and repos (tree view, flat view, formatting)."""
+
+import json
+from datetime import datetime
+from typing import Sequence
+
+import typer
+
+from huggingface_hub._buckets import BucketFile, BucketFolder
+from huggingface_hub.hf_api import RepoFile, RepoFolder
+
+from ._cli_utils import api_object_to_dict, get_hf_api
+from ._output import OutputFormatWithAuto, out
+
+
+BucketItem = BucketFile | BucketFolder
+RepoItem = RepoFile | RepoFolder
+ListingItem = BucketItem | RepoItem
+
+
+def get_item_date(item: ListingItem) -> datetime | None:
+    """Extract date from an item, supporting both repo items (last_commit.date) and bucket items (mtime/uploaded_at)."""
+    match item:
+        case BucketFile(mtime=mtime) if mtime is not None:
+            return mtime
+        case BucketFile(uploaded_at=uploaded_at) | BucketFolder(uploaded_at=uploaded_at) if uploaded_at is not None:
+            return uploaded_at
+        case RepoFile(last_commit=last_commit) | RepoFolder(last_commit=last_commit) if last_commit is not None:
+            return last_commit.date
+        case _:
+            return None
+
+
+def format_size(size: int | float, human_readable: bool = False) -> str:
+    """Format a size in bytes."""
+    if not human_readable:
+        return str(size)
+
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if size < 1000:
+            if unit == "B":
+                return f"{size} {unit}"
+            return f"{size:.1f} {unit}"
+        size /= 1000
+    return f"{size:.1f} PB"
+
+
+def format_date(dt: datetime | None, human_readable: bool = False) -> str:
+    """Format a datetime to a readable date string."""
+    if dt is None:
+        return ""
+    if human_readable:
+        return dt.strftime("%b %d %H:%M")
+    return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def build_tree(
+    items: Sequence[BucketItem] | Sequence[RepoItem],
+    human_readable: bool = False,
+    quiet: bool = False,
+) -> list[str]:
+    """Build a tree representation of files and directories.
+
+    Produces ASCII tree with size and date columns before the tree connector.
+    When quiet=True, only the tree structure is shown (no size/date).
+    """
+    tree: dict = {}
+
+    for item in items:
+        parts = item.path.split("/")
+        current = tree
+        for part in parts[:-1]:
+            if part not in current:
+                current[part] = {"__children__": {}}
+            current = current[part]["__children__"]
+
+        final_part = parts[-1]
+        if isinstance(item, BucketFolder | RepoFolder):
+            if final_part not in current:
+                current[final_part] = {"__children__": {}}
+        else:
+            current[final_part] = {"__item__": item}
+
+    prefix_width = 0
+    max_size_width = 0
+    max_date_width = 0
+    if not quiet:
+        for item in items:
+            if isinstance(item, BucketFile | RepoFile):
+                size_str = format_size(item.size, human_readable)
+                max_size_width = max(max_size_width, len(size_str))
+                date_str = format_date(get_item_date(item), human_readable)
+                max_date_width = max(max_date_width, len(date_str))
+        if max_size_width > 0:
+            prefix_width = max_size_width + 2 + max_date_width
+
+    lines: list[str] = []
+    _render_tree(
+        tree,
+        lines,
+        "",
+        prefix_width=prefix_width,
+        max_size_width=max_size_width,
+        human_readable=human_readable,
+    )
+    return lines
+
+
+def _render_tree(
+    node: dict,
+    lines: list[str],
+    indent: str,
+    prefix_width: int = 0,
+    max_size_width: int = 0,
+    human_readable: bool = False,
+) -> None:
+    """Recursively render a tree structure with size+date prefix."""
+    sorted_items = sorted(node.items())
+    for i, (name, value) in enumerate(sorted_items):
+        is_last = i == len(sorted_items) - 1
+        connector = "└── " if is_last else "├── "
+
+        is_dir = "__children__" in value
+        children = value.get("__children__", {})
+
+        if prefix_width > 0:
+            if is_dir:
+                prefix = " " * prefix_width
+            else:
+                item = value.get("__item__")
+                if item is not None:
+                    size_str = format_size(item.size, human_readable)
+                    date_str = format_date(get_item_date(item), human_readable)
+                    prefix = f"{size_str:>{max_size_width}}  {date_str}"
+                else:
+                    prefix = " " * prefix_width
+            lines.append(f"{prefix}  {indent}{connector}{name}{'/' if is_dir else ''}")
+        else:
+            lines.append(f"{indent}{connector}{name}{'/' if is_dir else ''}")
+
+        if children:
+            child_indent = indent + ("    " if is_last else "│   ")
+            _render_tree(
+                children,
+                lines,
+                child_indent,
+                prefix_width=prefix_width,
+                max_size_width=max_size_width,
+                human_readable=human_readable,
+            )
+
+
+def list_repo_files_cmd(
+    repo_id: str,
+    repo_type: str,
+    human_readable: bool,
+    as_tree: bool,
+    recursive: bool,
+    revision: str | None,
+    token: str | None,
+) -> None:
+    """List files in a repo on the Hub. Used by models/datasets/spaces ls commands."""
+    if as_tree and out.mode == OutputFormatWithAuto.json:
+        raise typer.BadParameter("Cannot use --tree with --format json.")
+
+    api = get_hf_api(token=token)
+    items = list(api.list_repo_tree(repo_id, recursive=recursive, revision=revision, repo_type=repo_type, expand=True))
+    print_file_listing(items, human_readable=human_readable, as_tree=as_tree, recursive=recursive)
+
+
+def print_file_listing(
+    items: Sequence[BucketItem] | Sequence[RepoItem],
+    *,
+    human_readable: bool = False,
+    as_tree: bool = False,
+    recursive: bool = False,
+) -> None:
+    """Print a file listing in the appropriate format based on the current output mode.
+
+    Supports tree, json, quiet, and flat human-readable views. Works with both
+    BucketFile/BucketFolder and RepoFile/RepoFolder items.
+    """
+    if not items:
+        out.text("(empty)")
+        return
+
+    has_directories = any(isinstance(item, BucketFolder | RepoFolder) for item in items)
+
+    if as_tree:
+        quiet = out.mode == OutputFormatWithAuto.quiet
+        for line in build_tree(items, human_readable=human_readable, quiet=quiet):
+            print(line)
+    elif out.mode == OutputFormatWithAuto.json:
+        print(json.dumps([api_object_to_dict(item) for item in items], indent=2))
+    elif out.mode == OutputFormatWithAuto.quiet:
+        for item in items:
+            if isinstance(item, BucketFolder | RepoFolder):
+                print(f"{item.path}/")
+            else:
+                print(item.path)
+    else:
+        for item in items:
+            if isinstance(item, BucketFolder | RepoFolder):
+                date_str = format_date(get_item_date(item), human_readable)
+                print(f"{'':>12}  {date_str:>19}  {item.path}/")
+            else:
+                size_str = format_size(item.size, human_readable)
+                date_str = format_date(get_item_date(item), human_readable)
+                print(f"{size_str:>12}  {date_str:>19}  {item.path}")
+
+    if not recursive and has_directories:
+        out.hint("Use -R to list files recursively.")

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/cli/_output.py

@@ -0,0 +1,272 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Output framework for the `hf` CLI."""
+
+import dataclasses
+import datetime
+import json
+import re
+import sys
+from collections.abc import Sequence
+from enum import Enum
+from typing import Any
+
+import typer
+
+from huggingface_hub.errors import ConfirmationError
+from huggingface_hub.utils import ANSI, StatusLine, disable_progress_bars, is_agent, tabulate
+
+
+# TODO: remove OutputFormat in _cli_utils.py once all commands are migrated to OutputFormatWithAuto.
+class OutputFormatWithAuto(str, Enum):
+    """Output format for CLI commands with auto detection of agent/human mode."""
+
+    agent = "agent"
+    auto = "auto"
+    human = "human"
+    json = "json"
+    quiet = "quiet"
+
+
+class Output:
+    """Output sink for the `hf` CLI.
+
+    Mode is resolved once at init time based on `is_agent()` auto-detection
+    and can be overridden per-command via `set_mode()`.
+    """
+
+    mode: OutputFormatWithAuto
+
+    def __init__(self) -> None:
+        self.set_mode()
+
+    def set_mode(self, mode: OutputFormatWithAuto = OutputFormatWithAuto.auto) -> None:
+        """Override the output mode (called once at startup and again per '--format' flag)."""
+        if mode == OutputFormatWithAuto.auto:
+            mode = OutputFormatWithAuto.agent if is_agent() else OutputFormatWithAuto.human
+        self.mode = mode
+        if mode != OutputFormatWithAuto.human:
+            disable_progress_bars()
+
+    def is_quiet(self) -> bool:
+        return self.mode == OutputFormatWithAuto.quiet
+
+    def text(self, msg: str | None = None, *, human: str | None = None, agent: str | None = None) -> None:
+        """Print a free-form text message to stdout."""
+        if msg is not None:
+            if human is not None or agent is not None:
+                raise ValueError("Cannot mix 'msg' with 'human'/'agent'.")
+            human = msg
+            agent = _strip_ansi(msg)
+
+        match self.mode:
+            case OutputFormatWithAuto.human:
+                if human is not None:
+                    print(human)
+            case OutputFormatWithAuto.agent:
+                if agent is not None:
+                    print(agent)
+            # json/quiet: no-op
+
+    def table(
+        self,
+        items: Sequence[dict[str, Any]],
+        *,
+        headers: list[str] | None = None,
+        id_key: str | None = None,
+        alignments: dict[str, str] | None = None,
+    ) -> None:
+        """Print tabular data to stdout.
+
+        Args:
+            items: List of dicts. Headers are auto-detected from keys if not provided.
+            headers: Explicit column names. If None, derived from dict keys (all-None columns filtered).
+            id_key: Key to print in quiet mode. If None, uses the first header.
+            alignments: Optional mapping of header name to "left" or "right". Defaults to "left".
+        """
+        if not items:
+            match self.mode:
+                case OutputFormatWithAuto.agent | OutputFormatWithAuto.human:
+                    print("No results found.")
+                case OutputFormatWithAuto.json:
+                    print("[]")
+            return
+
+        if headers is None:
+            all_columns = list(items[0].keys())
+            headers = [col for col in all_columns if any(item.get(col) is not None for item in items)]
+        rows = [[item.get(h) for h in headers] for item in items]
+
+        match self.mode:
+            case OutputFormatWithAuto.human:  # padded table, truncated cells, SCREAMING_SNAKE headers
+                formatted_rows: list[list[str | int]] = [[_format_table_cell_human(v) for v in row] for row in rows]
+                screaming_headers = [_to_header(h) for h in headers]
+                screaming_alignments = {_to_header(k): v for k, v in (alignments or {}).items()}
+                print(tabulate(formatted_rows, headers=screaming_headers, alignments=screaming_alignments))
+            case OutputFormatWithAuto.agent:  # TSV, no truncation, full timestamps
+                print("\t".join(headers))
+                for row in rows:
+                    print("\t".join(_format_table_cell_agent(v) for v in row))
+            case OutputFormatWithAuto.json:  # compact JSON array
+                print(json.dumps(list(items), default=str))
+            case OutputFormatWithAuto.quiet:  # id_key column (or first column), one per line
+                quiet_key = id_key or headers[0]
+                for item in items:
+                    print(item.get(quiet_key, ""))
+
+    def dict(self, data: Any, *, id_key: str | None = None) -> None:
+        """Print structured data as JSON in all modes (indented for human, compact otherwise).
+
+        Accepts a dict or a dataclass.
+        """
+        if dataclasses.is_dataclass(data) and not isinstance(data, type):
+            data = _dataclass_to_dict(data)
+        if self.mode == OutputFormatWithAuto.quiet and id_key is not None:
+            print(data.get(id_key, ""))
+            return
+        indent = 2 if self.mode == OutputFormatWithAuto.human else None
+        print(json.dumps(data, indent=indent, default=str))
+
+    def result(self, message: str, **data: Any) -> None:
+        """Print a success summary to stdout."""
+        match self.mode:
+            case OutputFormatWithAuto.human:  # ✓ message + key: value lines
+                parts = [ANSI.green(f"✓ {message}")]
+                for k, v in data.items():
+                    if v is not None:
+                        parts.append(f"  {k}: {v}")
+                print("\n".join(parts))
+            case OutputFormatWithAuto.agent:  # key=val pairs, space-separated
+                parts = [f"{k}={v}" for k, v in data.items() if v is not None]
+                print(" ".join(parts) if parts else message)
+            case OutputFormatWithAuto.json:  # json.dumps(data), message ignored
+                print(json.dumps(data, default=str) if data else "")
+            case OutputFormatWithAuto.quiet:  # first value only
+                values = list(data.values())
+                if values:
+                    print(values[0])
+
+    def confirm(self, message: str, *, default: bool = False, yes: bool = False) -> None:
+        """
+        Ask for confirmation. Raises `ConfirmationError` in non-human modes.
+        """
+        if yes:
+            return
+        if self.mode != OutputFormatWithAuto.human:
+            raise ConfirmationError(f"{message} Use --yes to skip confirmation.")
+        typer.confirm(message, default=default, abort=True)
+
+    def status(self, message: str | None = None) -> StatusLine:
+        """Return a status line that emits only in human mode (no-op otherwise)."""
+        status = StatusLine(enabled=self.mode == OutputFormatWithAuto.human)
+        if message is not None:
+            status.update(message)
+        return status
+
+    def warning(self, message: str) -> None:
+        """Print a non-fatal warning to stderr (all modes)."""
+        if self.mode == OutputFormatWithAuto.human:
+            print(ANSI.yellow(f"Warning: {message}"), file=sys.stderr)
+        else:
+            print(f"Warning: {message}", file=sys.stderr)
+
+    def error(self, message: str) -> None:
+        """Print an error to stderr (all modes)."""
+        if self.mode == OutputFormatWithAuto.human:
+            print(ANSI.red(f"Error: {message}"), file=sys.stderr)
+        else:
+            print(f"Error: {message}", file=sys.stderr)
+
+    def hint(self, message: str) -> None:
+        """Print a helpful hint to stderr (human: gray, agent/json: plain text)."""
+        if self.mode == OutputFormatWithAuto.human:
+            print(ANSI.gray(f"Hint: {message}"), file=sys.stderr)
+        else:
+            print(f"Hint: {message}", file=sys.stderr)
+
+
+# HELPERS
+
+
+def _serialize_value(v: object) -> object:
+    """Recursively serialize a value to be JSON-compatible."""
+    if isinstance(v, datetime.datetime):
+        return v.isoformat()
+    elif isinstance(v, dict):
+        return {key: _serialize_value(val) for key, val in v.items() if val is not None}
+    elif isinstance(v, list):
+        return [_serialize_value(item) for item in v]
+    return v
+
+
+def _dataclass_to_dict(info: Any) -> dict[str, Any]:
+    """Convert a dataclass to a json-serializable dict."""
+    return {k: _serialize_value(v) for k, v in dataclasses.asdict(info).items() if v is not None}
+
+
+_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
+_MAX_CELL_LENGTH = 35
+
+
+def _strip_ansi(text: str) -> str:
+    return _ANSI_RE.sub("", text)
+
+
+def _single_line(text: str) -> str:
+    return " ".join(text.split())
+
+
+def _to_header(name: str) -> str:
+    """Convert a camelCase or PascalCase string to SCREAMING_SNAKE_CASE."""
+    s = re.sub(r"([a-z])([A-Z])", r"\1_\2", name)
+    return s.upper()
+
+
+def _format_table_value_human(value: Any) -> str:
+    """Convert a value to string for terminal display."""
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "✔" if value else ""
+    if isinstance(value, datetime.datetime):
+        return value.strftime("%Y-%m-%d")
+    if isinstance(value, str) and re.match(r"^\d{4}-\d{2}-\d{2}T", value):
+        return value[:10]
+    if isinstance(value, str):
+        return _single_line(value)
+    if isinstance(value, list):
+        return ", ".join(_format_table_value_human(v) for v in value)
+    elif isinstance(value, dict):
+        if "name" in value:  # Likely to be a user or org => print name
+            return _single_line(str(value["name"]))
+        return _single_line(json.dumps(value))
+    return _single_line(str(value))
+
+
+def _format_table_cell_human(value: Any, max_len: int = _MAX_CELL_LENGTH) -> str:
+    """Format a value + truncate it for table display."""
+    cell = _format_table_value_human(value)
+    if len(cell) > max_len:
+        cell = cell[: max_len - 3] + "..."
+    return cell
+
+
+def _format_table_cell_agent(value: Any) -> str:
+    """Format a cell value for agent TSV output (ISO timestamps, tabs escaped)."""
+    if isinstance(value, datetime.datetime):
+        return value.isoformat()
+    return _single_line(str(value))
+
+
+out = Output()

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/cli/_skills.py

@@ -0,0 +1,252 @@
+"""Internal helpers for Hugging Face marketplace skill installation and upgrades."""
+
+import json
+import shutil
+import tempfile
+from dataclasses import dataclass, replace
+from pathlib import Path, PurePosixPath
+from typing import Any, Literal
+
+from huggingface_hub._buckets import BucketFile
+from huggingface_hub.errors import CLIError
+
+from ..utils import disable_progress_bars
+from ._cli_utils import get_hf_api
+
+
+DEFAULT_SKILLS_BUCKET_ID = "huggingface/skills"
+MARKETPLACE_PATH = "marketplace.json"
+# Empty marker file dropped into managed skill installs so `hf skills update` knows
+# to touch them and leave user-placed skill dirs alone. Filename is historical (used
+# to be a JSON manifest with a revision); we keep it for backward compat with installs
+# made by previous versions.
+MANAGED_MARKER_FILENAME = ".hf-skill-manifest.json"
+
+SkillUpdateStatus = Literal["up_to_date", "unmanaged", "source_unreachable"]
+
+
+@dataclass(frozen=True)
+class MarketplaceSkill:
+    name: str
+    repo_path: str
+
+
+@dataclass(frozen=True)
+class SkillUpdateInfo:
+    name: str
+    skill_dir: Path
+    status: SkillUpdateStatus
+    detail: str | None = None
+
+
+def add_skill(skill_name: str, destination_root: Path, force: bool = False) -> Path:
+    """Resolve a marketplace skill by name and install it."""
+    api = get_hf_api()
+    with disable_progress_bars():
+        marketplace_skills = _load_marketplace_skills(api)
+        skill = _select_marketplace_skill(marketplace_skills, skill_name)
+        if skill is None:
+            raise CLIError(
+                f"Skill '{skill_name}' not found in {DEFAULT_SKILLS_BUCKET_ID}. "
+                "Try `hf skills add` to install `hf-cli` or use a known skill name."
+            )
+        return _install_marketplace_skill(api, skill, destination_root, force=force)
+
+
+def update_skills(roots: list[Path], selector: str | None = None) -> list[SkillUpdateInfo]:
+    """Re-sync managed marketplace skill installs from the bucket."""
+    skill_dirs = _iter_unique_skill_dirs(roots)
+    if selector is not None:
+        selector_lower = selector.strip().lower()
+        skill_dirs = [d for d in skill_dirs if d.name.lower() == selector_lower]
+        if not skill_dirs:
+            raise CLIError(f"No installed skill matches '{selector}'. Install it with `hf skills add {selector}`.")
+
+    api = get_hf_api()
+    with disable_progress_bars():
+        marketplace_skills = {skill.name.lower(): skill for skill in _load_marketplace_skills(api)}
+        return [_apply_single_update(api, skill_dir, marketplace_skills) for skill_dir in skill_dirs]
+
+
+def _load_marketplace_skills(api) -> list[MarketplaceSkill]:
+    payload = _load_marketplace_payload(api)
+    plugins = payload.get("plugins")
+    if not isinstance(plugins, list):
+        raise CLIError("Invalid marketplace payload: expected a top-level 'plugins' list.")
+
+    skills: list[MarketplaceSkill] = []
+    for plugin in plugins:
+        if not isinstance(plugin, dict):
+            continue
+        name = plugin.get("name")
+        source = plugin.get("source")
+        if not isinstance(name, str) or not isinstance(source, str):
+            continue
+        skills.append(MarketplaceSkill(name=name, repo_path=_normalize_repo_path(source)))
+    return skills
+
+
+def _install_marketplace_skill(api, skill: MarketplaceSkill, destination_root: Path, force: bool = False) -> Path:
+    """Install a marketplace skill into a local skills directory."""
+    destination_root = destination_root.expanduser().resolve()
+    destination_root.mkdir(parents=True, exist_ok=True)
+    install_dir = destination_root / skill.name
+    already_exists = install_dir.exists()
+
+    if already_exists and not force:
+        raise FileExistsError(f"Skill already exists: {install_dir}")
+
+    if already_exists:
+        # Stage the new content in a sibling tempdir and atomically rename, so the
+        # existing install stays intact if the download fails halfway through.
+        with tempfile.TemporaryDirectory(dir=destination_root, prefix=f".{install_dir.name}.install-") as tmp_dir_str:
+            staged_dir = Path(tmp_dir_str) / install_dir.name
+            _populate_install_dir(api, skill=skill, install_dir=staged_dir)
+            _atomic_replace_directory(existing_dir=install_dir, staged_dir=staged_dir)
+        return install_dir
+
+    try:
+        _populate_install_dir(api, skill=skill, install_dir=install_dir)
+    except Exception:
+        if install_dir.exists():
+            shutil.rmtree(install_dir)
+        raise
+    return install_dir
+
+
+def _load_marketplace_payload(api) -> dict[str, Any]:
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        local_path = Path(tmp_dir) / "marketplace.json"
+        api.download_bucket_files(
+            DEFAULT_SKILLS_BUCKET_ID,
+            [(MARKETPLACE_PATH, local_path)],
+            raise_on_missing_files=True,
+        )
+        parsed = json.loads(local_path.read_text(encoding="utf-8"))
+
+    if not isinstance(parsed, dict):
+        raise CLIError("Invalid marketplace payload: expected a JSON object.")
+    return parsed
+
+
+def _select_marketplace_skill(skills: list[MarketplaceSkill], selector: str) -> MarketplaceSkill | None:
+    selector_lower = selector.strip().lower()
+    for skill in skills:
+        if skill.name.lower() == selector_lower:
+            return skill
+    return None
+
+
+def _normalize_repo_path(path: str) -> str:
+    normalized = path.strip()
+    while normalized.startswith("./"):
+        normalized = normalized[2:]
+    normalized = normalized.strip("/")
+    if not normalized:
+        raise CLIError("Invalid marketplace entry: empty source path.")
+    return normalized
+
+
+def _populate_install_dir(api, skill: MarketplaceSkill, install_dir: Path) -> None:
+    install_dir.mkdir(parents=True, exist_ok=True)
+    bucket_files = _list_skill_files(api, skill)
+    _download_skill_files(api, skill, bucket_files, install_dir)
+    _validate_installed_skill_dir(install_dir)
+    (install_dir / MANAGED_MARKER_FILENAME).touch()
+
+
+def _validate_installed_skill_dir(skill_dir: Path) -> None:
+    skill_file = skill_dir / "SKILL.md"
+    if not skill_file.is_file():
+        raise RuntimeError(f"Installed skill is missing SKILL.md: {skill_file}")
+
+
+def _list_skill_files(api, skill: MarketplaceSkill) -> list[BucketFile]:
+    """List all files under `skill.repo_path` in the marketplace bucket."""
+    prefix = skill.repo_path.rstrip("/")
+    files: list[BucketFile] = [
+        item
+        for item in api.list_bucket_tree(DEFAULT_SKILLS_BUCKET_ID, prefix=prefix, recursive=True)
+        if isinstance(item, BucketFile)
+    ]
+    if not files:
+        raise FileNotFoundError(f"Path '{prefix}' not found in bucket '{DEFAULT_SKILLS_BUCKET_ID}'.")
+    return files
+
+
+def _download_skill_files(api, skill: MarketplaceSkill, files: list[BucketFile], install_dir: Path) -> None:
+    """Download bucket files into `install_dir`."""
+    prefix = skill.repo_path.rstrip("/")
+    prefix_with_slash = f"{prefix}/"
+
+    # `list_bucket_tree(prefix=...)` matches as a raw string prefix, so e.g. asking for
+    # "skills/gradio" can also return "skills/gradio-tools/...". Filter on the trailing
+    # slash to keep only files actually inside the directory, then strip it so files land
+    # directly under `install_dir` preserving any nested structure.
+    download_specs: list[tuple[str | BucketFile, str | Path]] = []
+    for bucket_file in files:
+        if not bucket_file.path.startswith(prefix_with_slash):
+            continue
+        relative = bucket_file.path[len(prefix_with_slash) :]
+        local_file = install_dir.joinpath(*PurePosixPath(relative).parts)
+        local_file.parent.mkdir(parents=True, exist_ok=True)
+        download_specs.append((bucket_file, local_file))
+
+    if not download_specs:
+        raise FileNotFoundError(f"No files found under '{prefix}' in bucket '{DEFAULT_SKILLS_BUCKET_ID}'.")
+
+    api.download_bucket_files(DEFAULT_SKILLS_BUCKET_ID, download_specs)
+
+
+def _atomic_replace_directory(existing_dir: Path, staged_dir: Path) -> None:
+    backup_dir = staged_dir.parent / f"{existing_dir.name}.backup"
+    try:
+        existing_dir.rename(backup_dir)
+        staged_dir.rename(existing_dir)
+        shutil.rmtree(backup_dir)
+    except Exception:
+        if backup_dir.exists() and not existing_dir.exists():
+            backup_dir.rename(existing_dir)
+        raise
+
+
+def _iter_unique_skill_dirs(roots: list[Path]) -> list[Path]:
+    seen: set[Path] = set()
+    discovered: list[Path] = []
+    for root in roots:
+        root = root.expanduser().resolve()
+        if not root.is_dir():
+            continue
+        for child in sorted(root.iterdir()):
+            if child.name.startswith("."):
+                continue
+            if not child.is_dir() and not child.is_symlink():
+                continue
+            resolved = child.resolve()
+            if resolved in seen or not resolved.is_dir():
+                continue
+            seen.add(resolved)
+            discovered.append(resolved)
+    return discovered
+
+
+def _apply_single_update(api, skill_dir: Path, marketplace_skills: dict[str, MarketplaceSkill]) -> SkillUpdateInfo:
+    base = SkillUpdateInfo(name=skill_dir.name, skill_dir=skill_dir, status="unmanaged")
+
+    if not (skill_dir / MANAGED_MARKER_FILENAME).exists():
+        return base
+
+    skill = marketplace_skills.get(skill_dir.name.lower())
+    if skill is None:
+        return replace(
+            base,
+            status="source_unreachable",
+            detail=f"Skill '{skill_dir.name}' is no longer available in {DEFAULT_SKILLS_BUCKET_ID}.",
+        )
+
+    try:
+        _install_marketplace_skill(api, skill, skill_dir.parent, force=True)
+    except Exception as exc:
+        return replace(base, status="source_unreachable", detail=str(exc))
+
+    return replace(base, status="up_to_date")

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/cli/auth.py

@@ -0,0 +1,174 @@
+# Copyright 2020 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains commands to authenticate to the Hugging Face Hub and interact with your repositories.
+
+Usage:
+    # login and save token locally.
+    hf auth login --token=hf_*** --add-to-git-credential
+
+    # switch between tokens
+    hf auth switch
+
+    # list all tokens
+    hf auth list
+
+    # logout from all tokens
+    hf auth logout
+
+    # check which account you are logged in as
+    hf auth whoami
+"""
+
+from typing import Annotated
+
+import typer
+
+from huggingface_hub.constants import ENDPOINT
+from huggingface_hub.hf_api import whoami
+
+from .._login import auth_list, auth_switch, login, logout
+from ..utils import get_stored_tokens, get_token, logging
+from ._cli_utils import TokenOpt, typer_factory
+from ._output import out
+
+
+logger = logging.get_logger(__name__)
+
+
+auth_cli = typer_factory(help="Manage authentication (login, logout, etc.).")
+
+
+@auth_cli.command(
+    "login",
+    examples=[
+        "hf auth login",
+        "hf auth login --token $HF_TOKEN",
+        "hf auth login --token $HF_TOKEN --add-to-git-credential",
+        "hf auth login --force",
+    ],
+)
+def auth_login(
+    token: TokenOpt = None,
+    add_to_git_credential: Annotated[
+        bool,
+        typer.Option(
+            help="Save to git credential helper. Useful only if you plan to run git commands directly.",
+        ),
+    ] = False,
+    force: Annotated[
+        bool,
+        typer.Option(
+            help="Force re-login even if already logged in.",
+        ),
+    ] = False,
+) -> None:
+    """Login using a token from huggingface.co/settings/tokens."""
+    login(token=token, add_to_git_credential=add_to_git_credential, skip_if_logged_in=not force)
+
+
+@auth_cli.command(
+    "logout",
+    examples=["hf auth logout", "hf auth logout --token-name my-token"],
+)
+def auth_logout(
+    token_name: Annotated[
+        str | None,
+        typer.Option(help="Name of token to logout"),
+    ] = None,
+) -> None:
+    """Logout from a specific token."""
+    logout(token_name=token_name)
+
+
+def _select_token_name() -> str | None:
+    token_names = list(get_stored_tokens().keys())
+
+    if not token_names:
+        logger.error("No stored tokens found. Please login first.")
+        return None
+
+    print("Available stored tokens:")
+    for i, token_name in enumerate(token_names, 1):
+        print(f"{i}. {token_name}")
+    while True:
+        try:
+            choice = input("Enter the number of the token to switch to (or 'q' to quit): ")
+            if choice.lower() == "q":
+                return None
+            index = int(choice) - 1
+            if 0 <= index < len(token_names):
+                return token_names[index]
+            else:
+                print("Invalid selection. Please try again.")
+        except ValueError:
+            print("Invalid input. Please enter a number or 'q' to quit.")
+
+
+@auth_cli.command(
+    "switch",
+    examples=["hf auth switch", "hf auth switch --token-name my-token"],
+)
+def auth_switch_cmd(
+    token_name: Annotated[
+        str | None,
+        typer.Option(
+            help="Name of the token to switch to",
+        ),
+    ] = None,
+    add_to_git_credential: Annotated[
+        bool,
+        typer.Option(
+            help="Save to git credential helper. Useful only if you plan to run git commands directly.",
+        ),
+    ] = False,
+) -> None:
+    """Switch between access tokens."""
+    if token_name is None:
+        token_name = _select_token_name()
+    if token_name is None:
+        print("No token name provided. Aborting.")
+        raise typer.Exit()
+    auth_switch(token_name, add_to_git_credential=add_to_git_credential)
+
+
+@auth_cli.command("list | ls", examples=["hf auth list"])
+def auth_list_cmd() -> None:
+    """List all stored access tokens."""
+    auth_list()
+
+
+@auth_cli.command("token", examples=["hf auth token", "hf auth token | xargs curl -H 'Authorization: Bearer {}'"])
+def auth_token() -> None:
+    """Print the current access token to stdout."""
+    token = get_token()
+    if token is None:
+        out.error("Not logged in. Run `hf auth login` first.")
+        raise typer.Exit(code=1)
+    print(token)
+    out.hint("Run `hf auth whoami` to see which account this token belongs to.")
+
+
+@auth_cli.command("whoami", examples=["hf auth whoami", "hf auth whoami --format json"])
+def auth_whoami() -> None:
+    """Find out which huggingface.co account you are logged in as."""
+
+    token = get_token()
+    if token is None:
+        out.error("Not logged in")
+        raise typer.Exit(code=1)
+
+    info = whoami(token)
+    orgs = ",".join(org["name"] for org in info["orgs"]) or None
+    endpoint = ENDPOINT if ENDPOINT != "https://huggingface.co" else None
+    out.result("Logged in", user=info["name"], orgs=orgs, endpoint=endpoint)

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/cli/buckets.py

@@ -0,0 +1,821 @@
+# Copyright 2025-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains commands to interact with buckets via the CLI."""
+
+import os
+import sys
+from typing import Annotated
+
+import typer
+
+from huggingface_hub import logging
+from huggingface_hub._buckets import (
+    BUCKET_PREFIX,
+    BucketFile,
+    FilterMatcher,
+    _is_bucket_path,
+    _parse_bucket_path,
+    _split_bucket_id_and_prefix,
+)
+from huggingface_hub.utils import (
+    SoftTemporaryDirectory,
+    disable_progress_bars,
+)
+
+from ._cli_utils import (
+    SearchOpt,
+    TokenOpt,
+    get_hf_api,
+    typer_factory,
+)
+from ._file_listing import format_size, print_file_listing
+from ._output import OutputFormatWithAuto, out
+
+
+logger = logging.get_logger(__name__)
+
+
+buckets_cli = typer_factory(help="Commands to interact with buckets.")
+
+
+def _is_hf_handle(path: str) -> bool:
+    return path.startswith("hf://")
+
+
+def _parse_bucket_argument(argument: str) -> tuple[str, str]:
+    """Parse a bucket argument accepting both 'namespace/name(/prefix)' and 'hf://buckets/namespace/name(/prefix)'.
+
+    Returns:
+        tuple: (bucket_id, prefix) where bucket_id is "namespace/bucket_name" and prefix may be empty string.
+    """
+    if argument.startswith(BUCKET_PREFIX):
+        return _parse_bucket_path(argument)
+    try:
+        return _split_bucket_id_and_prefix(argument)
+    except ValueError:
+        raise ValueError(
+            f"Invalid bucket argument: {argument}. Must be in format namespace/bucket_name"
+            f" or {BUCKET_PREFIX}namespace/bucket_name"
+        )
+
+
+@buckets_cli.command(
+    name="create",
+    examples=[
+        "hf buckets create my-bucket",
+        "hf buckets create user/my-bucket",
+        "hf buckets create hf://buckets/user/my-bucket",
+        "hf buckets create user/my-bucket --private",
+        "hf buckets create user/my-bucket --exist-ok",
+    ],
+)
+def create(
+    bucket_id: Annotated[
+        str,
+        typer.Argument(
+            help="Bucket ID: bucket_name, namespace/bucket_name, or hf://buckets/namespace/bucket_name",
+        ),
+    ],
+    private: Annotated[
+        bool,
+        typer.Option(
+            "--private",
+            help="Create a private bucket.",
+        ),
+    ] = False,
+    exist_ok: Annotated[
+        bool,
+        typer.Option(
+            "--exist-ok",
+            help="Do not raise an error if the bucket already exists.",
+        ),
+    ] = False,
+    token: TokenOpt = None,
+) -> None:
+    """Create a new bucket."""
+    api = get_hf_api(token=token)
+
+    if bucket_id.startswith(BUCKET_PREFIX):
+        try:
+            parsed_id, prefix = _parse_bucket_argument(bucket_id)
+        except ValueError as e:
+            raise typer.BadParameter(str(e))
+        if prefix:
+            raise typer.BadParameter(
+                f"Cannot specify a prefix for bucket creation: {bucket_id}."
+                f" Use namespace/bucket_name or {BUCKET_PREFIX}namespace/bucket_name."
+            )
+        bucket_id = parsed_id
+
+    bucket_url = api.create_bucket(
+        bucket_id,
+        private=private if private else None,
+        exist_ok=exist_ok,
+    )
+    out.result("Bucket created", handle=bucket_url.handle, url=bucket_url.url)
+
+
+def _is_bucket_id(argument: str) -> bool:
+    """Check if argument is a bucket ID (namespace/name) vs just a namespace."""
+    if argument.startswith(BUCKET_PREFIX):
+        path = argument[len(BUCKET_PREFIX) :]
+    else:
+        path = argument
+    return "/" in path
+
+
+@buckets_cli.command(
+    name="list | ls",
+    examples=[
+        "hf buckets list",
+        "hf buckets list huggingface",
+        'hf buckets list --search "my-prefix"',
+        "hf buckets list user/my-bucket",
+        "hf buckets list user/my-bucket -R",
+        "hf buckets list user/my-bucket -h",
+        "hf buckets list user/my-bucket --tree",
+        "hf buckets list user/my-bucket --tree -h",
+        "hf buckets list hf://buckets/user/my-bucket",
+        "hf buckets list user/my-bucket/sub -R",
+    ],
+)
+def list_cmd(
+    argument: Annotated[
+        str | None,
+        typer.Argument(
+            help=(
+                "Namespace (user or org) to list buckets, or bucket ID"
+                " (namespace/bucket_name(/prefix) or hf://buckets/...) to list files."
+            ),
+        ),
+    ] = None,
+    human_readable: Annotated[
+        bool,
+        typer.Option(
+            "--human-readable",
+            "-h",
+            help="Show sizes in human readable format.",
+        ),
+    ] = False,
+    as_tree: Annotated[
+        bool,
+        typer.Option(
+            "--tree",
+            help="List files in tree format (only for listing files).",
+        ),
+    ] = False,
+    recursive: Annotated[
+        bool,
+        typer.Option(
+            "--recursive",
+            "-R",
+            help="List files recursively (only for listing files).",
+        ),
+    ] = False,
+    search: SearchOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """List buckets or files in a bucket.
+
+    When called with no argument or a namespace, lists buckets.
+    When called with a bucket ID (namespace/bucket_name), lists files in the bucket.
+    """
+    # Determine mode: listing buckets or listing files
+    is_file_mode = argument is not None and _is_bucket_id(argument)
+
+    if is_file_mode:
+        if search is not None:
+            raise typer.BadParameter("Cannot use --search when listing files.")
+        _list_files(
+            argument=argument,  # type: ignore
+            human_readable=human_readable,
+            as_tree=as_tree,
+            recursive=recursive,
+            token=token,
+        )
+    else:
+        _list_buckets(
+            namespace=argument,
+            search=search,
+            human_readable=human_readable,
+            as_tree=as_tree,
+            recursive=recursive,
+            token=token,
+        )
+
+
+def _list_buckets(
+    namespace: str | None,
+    search: str | None,
+    human_readable: bool,
+    as_tree: bool,
+    recursive: bool,
+    token: str | None,
+) -> None:
+    """List buckets in a namespace."""
+    # Validate incompatible flags
+    if as_tree:
+        raise typer.BadParameter("Cannot use --tree when listing buckets.")
+    if recursive:
+        raise typer.BadParameter("Cannot use --recursive when listing buckets.")
+
+    # Handle hf://buckets/namespace format
+    if namespace is not None and namespace.startswith(BUCKET_PREFIX):
+        namespace = namespace[len(BUCKET_PREFIX) :]
+        # Strip trailing slash if any
+        namespace = namespace.rstrip("/")
+
+    api = get_hf_api(token=token)
+    items = [
+        {
+            "id": bucket.id,
+            "private": bucket.private,
+            "size": format_size(bucket.size, human_readable) if human_readable else bucket.size,
+            "total_files": bucket.total_files,
+            "created_at": bucket.created_at,
+        }
+        for bucket in api.list_buckets(namespace=namespace, search=search)
+    ]
+    out.table(items, alignments={"size": "right", "total_files": "right"})
+
+
+def _list_files(
+    argument: str,
+    human_readable: bool,
+    as_tree: bool,
+    recursive: bool,
+    token: str | None,
+) -> None:
+    """List files in a bucket."""
+    if as_tree and out.mode == OutputFormatWithAuto.json:
+        raise typer.BadParameter("Cannot use --tree with --format json.")
+
+    api = get_hf_api(token=token)
+
+    try:
+        bucket_id, prefix = _parse_bucket_argument(argument)
+    except ValueError as e:
+        raise typer.BadParameter(str(e))
+
+    items = list(
+        api.list_bucket_tree(
+            bucket_id,
+            prefix=prefix or None,
+            recursive=recursive,
+        )
+    )
+
+    print_file_listing(items, human_readable=human_readable, as_tree=as_tree, recursive=recursive)
+
+
+@buckets_cli.command(
+    name="info",
+    examples=[
+        "hf buckets info user/my-bucket",
+        "hf buckets info hf://buckets/user/my-bucket",
+    ],
+)
+def info(
+    bucket_id: Annotated[
+        str,
+        typer.Argument(
+            help="Bucket ID: namespace/bucket_name or hf://buckets/namespace/bucket_name",
+        ),
+    ],
+    token: TokenOpt = None,
+) -> None:
+    """Get info about a bucket."""
+    api = get_hf_api(token=token)
+
+    try:
+        parsed_id, _ = _parse_bucket_argument(bucket_id)
+    except ValueError as e:
+        raise typer.BadParameter(str(e))
+
+    bucket = api.bucket_info(parsed_id)
+    out.dict(bucket, id_key="id")
+
+
+@buckets_cli.command(
+    name="delete",
+    examples=[
+        "hf buckets delete user/my-bucket",
+        "hf buckets delete hf://buckets/user/my-bucket",
+        "hf buckets delete user/my-bucket --yes",
+        "hf buckets delete user/my-bucket --missing-ok",
+    ],
+)
+def delete(
+    bucket_id: Annotated[
+        str,
+        typer.Argument(
+            help="Bucket ID: namespace/bucket_name or hf://buckets/namespace/bucket_name",
+        ),
+    ],
+    yes: Annotated[
+        bool,
+        typer.Option(
+            "--yes",
+            "-y",
+            help="Skip confirmation prompt.",
+        ),
+    ] = False,
+    missing_ok: Annotated[
+        bool,
+        typer.Option(
+            "--missing-ok",
+            help="Do not raise an error if the bucket does not exist.",
+        ),
+    ] = False,
+    token: TokenOpt = None,
+) -> None:
+    """Delete a bucket.
+
+    This deletes the entire bucket and all its contents. Use `hf buckets rm` to remove individual files.
+    """
+    if bucket_id.startswith(BUCKET_PREFIX):
+        try:
+            parsed_id, prefix = _parse_bucket_argument(bucket_id)
+        except ValueError as e:
+            raise typer.BadParameter(str(e))
+        if prefix:
+            raise typer.BadParameter(
+                f"Cannot specify a prefix for bucket deletion: {bucket_id}."
+                f" Use namespace/bucket_name or {BUCKET_PREFIX}namespace/bucket_name."
+            )
+        bucket_id = parsed_id
+    elif "/" not in bucket_id:
+        raise typer.BadParameter(
+            f"Invalid bucket ID: {bucket_id}."
+            f" Must be in format namespace/bucket_name or {BUCKET_PREFIX}namespace/bucket_name."
+        )
+
+    out.confirm(f"Are you sure you want to delete bucket '{bucket_id}'?", yes=yes)
+
+    api = get_hf_api(token=token)
+    api.delete_bucket(bucket_id, missing_ok=missing_ok)
+    out.result("Bucket deleted", bucket_id=bucket_id)
+
+
+@buckets_cli.command(
+    name="remove | rm",
+    examples=[
+        "hf buckets remove user/my-bucket/file.txt",
+        "hf buckets rm hf://buckets/user/my-bucket/file.txt",
+        "hf buckets rm user/my-bucket/logs/ --recursive",
+        'hf buckets rm user/my-bucket --recursive --include "*.tmp"',
+        "hf buckets rm user/my-bucket/data/ --recursive --dry-run",
+    ],
+)
+def remove(
+    argument: Annotated[
+        str,
+        typer.Argument(
+            help=(
+                "Bucket path: namespace/bucket_name/path or hf://buckets/namespace/bucket_name/path."
+                " With --recursive, namespace/bucket_name is also accepted to target all files."
+            ),
+        ),
+    ],
+    recursive: Annotated[
+        bool,
+        typer.Option(
+            "--recursive",
+            "-R",
+            help="Remove files recursively under the given prefix.",
+        ),
+    ] = False,
+    yes: Annotated[
+        bool,
+        typer.Option(
+            "--yes",
+            "-y",
+            help="Skip confirmation prompt.",
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            "--dry-run",
+            help="Preview what would be deleted without actually deleting.",
+        ),
+    ] = False,
+    include: Annotated[
+        list[str] | None,
+        typer.Option(
+            help="Include only files matching pattern (can specify multiple). Requires --recursive.",
+        ),
+    ] = None,
+    exclude: Annotated[
+        list[str] | None,
+        typer.Option(
+            help="Exclude files matching pattern (can specify multiple). Requires --recursive.",
+        ),
+    ] = None,
+    token: TokenOpt = None,
+) -> None:
+    """Remove files from a bucket.
+
+    To delete an entire bucket, use `hf buckets delete` instead.
+    """
+    try:
+        bucket_id, prefix = _parse_bucket_argument(argument)
+    except ValueError as e:
+        raise typer.BadParameter(str(e))
+
+    if prefix == "" and not recursive:
+        raise typer.BadParameter(
+            f"No file path specified. To remove files, provide a path"
+            f" (e.g. '{bucket_id}/FILE') or use --recursive to remove all files."
+            f" To delete the entire bucket, use `hf buckets delete {bucket_id}`."
+        )
+
+    if (include or exclude) and not recursive:
+        raise typer.BadParameter("--include and --exclude require --recursive.")
+
+    api = get_hf_api(token=token)
+
+    if recursive:
+        status = out.status("Listing files from remote")
+
+        all_files: list[BucketFile] = []
+        for item in api.list_bucket_tree(
+            bucket_id,
+            prefix=prefix.rstrip("/") or None,
+            recursive=True,
+        ):
+            if isinstance(item, BucketFile):
+                all_files.append(item)
+                status.update(f"Listing files from remote ({len(all_files)} files)")
+        status.done(f"Listing files from remote ({len(all_files)} files)")
+
+        if include or exclude:
+            matcher = FilterMatcher(include_patterns=include, exclude_patterns=exclude)
+            matched_files = [f for f in all_files if matcher.matches(f.path)]
+        else:
+            matched_files = all_files
+
+        file_paths = [f.path for f in matched_files]
+        total_size = sum(f.size for f in matched_files)
+        size_str = format_size(total_size, human_readable=True)
+
+        if not file_paths:
+            out.text("No files to remove.")
+            return
+
+        count_label = f"{len(file_paths)} file(s) totaling {size_str}"
+
+        if not yes and not dry_run:
+            out.text("\n".join(f"  {path}" for path in file_paths))
+            out.confirm(f"Remove {count_label} from '{bucket_id}'?", yes=False)
+
+        if dry_run:
+            out.text("\n".join(f"delete: {BUCKET_PREFIX}{bucket_id}/{path}" for path in file_paths))
+            out.text(f"(dry run) {count_label} would be removed.")
+            return
+
+        api.batch_bucket_files(bucket_id, delete=file_paths)
+        out.result(
+            f"Removed {count_label} from '{bucket_id}'",
+            bucket_id=bucket_id,
+            files_deleted=len(file_paths),
+            size=size_str,
+        )
+
+    else:
+        file_path = prefix.rstrip("/")
+        if not file_path:
+            raise typer.BadParameter("File path cannot be empty.")
+
+        if dry_run:
+            out.text(f"delete: {BUCKET_PREFIX}{bucket_id}/{file_path}")
+            out.text("(dry run) 1 file would be removed.")
+            return
+
+        out.confirm(f"Remove '{file_path}' from '{bucket_id}'?", yes=yes)
+
+        api.batch_bucket_files(bucket_id, delete=[file_path])
+        out.result("File removed", path=file_path, bucket_id=bucket_id)
+
+
+@buckets_cli.command(
+    name="move",
+    examples=[
+        "hf buckets move user/old-bucket user/new-bucket",
+        "hf buckets move user/my-bucket my-org/my-bucket",
+        "hf buckets move hf://buckets/user/old-bucket hf://buckets/user/new-bucket",
+    ],
+)
+def move(
+    from_id: Annotated[
+        str,
+        typer.Argument(
+            help="Source bucket ID: namespace/bucket_name or hf://buckets/namespace/bucket_name",
+        ),
+    ],
+    to_id: Annotated[
+        str,
+        typer.Argument(
+            help="Destination bucket ID: namespace/bucket_name or hf://buckets/namespace/bucket_name",
+        ),
+    ],
+    token: TokenOpt = None,
+) -> None:
+    """Move (rename) a bucket to a new name or namespace."""
+    # Parse from_id
+    parsed_from_id, from_prefix = _parse_bucket_argument(from_id)
+    if from_prefix:
+        raise typer.BadParameter(
+            f"Cannot specify a prefix for bucket move: {from_id}."
+            f" Use namespace/bucket_name or {BUCKET_PREFIX}namespace/bucket_name."
+        )
+
+    # Parse to_id
+    parsed_to_id, to_prefix = _parse_bucket_argument(to_id)
+    if to_prefix:
+        raise typer.BadParameter(
+            f"Cannot specify a prefix for bucket move: {to_id}."
+            f" Use namespace/bucket_name or {BUCKET_PREFIX}namespace/bucket_name."
+        )
+
+    api = get_hf_api(token=token)
+    api.move_bucket(from_id=parsed_from_id, to_id=parsed_to_id)
+    out.result("Bucket moved", from_id=parsed_from_id, to_id=parsed_to_id)
+
+
+# =============================================================================
+# Sync command
+# =============================================================================
+
+
+@buckets_cli.command(
+    name="sync",
+    examples=[
+        "hf buckets sync ./data hf://buckets/user/my-bucket",
+        "hf buckets sync hf://buckets/user/my-bucket ./data",
+        "hf buckets sync ./data hf://buckets/user/my-bucket --delete",
+        'hf buckets sync hf://buckets/user/my-bucket ./data --include "*.safetensors" --exclude "*.tmp"',
+        "hf buckets sync ./data hf://buckets/user/my-bucket --plan sync-plan.jsonl",
+        "hf buckets sync --apply sync-plan.jsonl",
+        "hf buckets sync ./data hf://buckets/user/my-bucket --dry-run",
+        "hf buckets sync ./data hf://buckets/user/my-bucket --dry-run | jq .",
+    ],
+)
+def sync(
+    source: Annotated[
+        str | None,
+        typer.Argument(
+            help="Source path: local directory or hf://buckets/namespace/bucket_name(/prefix)",
+        ),
+    ] = None,
+    dest: Annotated[
+        str | None,
+        typer.Argument(
+            help="Destination path: local directory or hf://buckets/namespace/bucket_name(/prefix)",
+        ),
+    ] = None,
+    delete: Annotated[
+        bool,
+        typer.Option(
+            help="Delete destination files not present in source.",
+        ),
+    ] = False,
+    ignore_times: Annotated[
+        bool,
+        typer.Option(
+            "--ignore-times",
+            help="Skip files only based on size, ignoring modification times.",
+        ),
+    ] = False,
+    ignore_sizes: Annotated[
+        bool,
+        typer.Option(
+            "--ignore-sizes",
+            help="Skip files only based on modification times, ignoring sizes.",
+        ),
+    ] = False,
+    plan: Annotated[
+        str | None,
+        typer.Option(
+            help="Save sync plan to JSONL file for review instead of executing.",
+        ),
+    ] = None,
+    apply: Annotated[
+        str | None,
+        typer.Option(
+            help="Apply a previously saved plan file.",
+        ),
+    ] = None,
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            "--dry-run",
+            help="Print sync plan to stdout as JSONL without executing.",
+        ),
+    ] = False,
+    include: Annotated[
+        list[str] | None,
+        typer.Option(
+            help="Include files matching pattern (can specify multiple).",
+        ),
+    ] = None,
+    exclude: Annotated[
+        list[str] | None,
+        typer.Option(
+            help="Exclude files matching pattern (can specify multiple).",
+        ),
+    ] = None,
+    filter_from: Annotated[
+        str | None,
+        typer.Option(
+            help="Read include/exclude patterns from file.",
+        ),
+    ] = None,
+    existing: Annotated[
+        bool,
+        typer.Option(
+            "--existing",
+            help="Skip creating new files on receiver (only update existing files).",
+        ),
+    ] = False,
+    ignore_existing: Annotated[
+        bool,
+        typer.Option(
+            "--ignore-existing",
+            help="Skip updating files that exist on receiver (only create new files).",
+        ),
+    ] = False,
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose",
+            "-v",
+            help="Show detailed logging with reasoning.",
+        ),
+    ] = False,
+    token: TokenOpt = None,
+) -> None:
+    """Sync files between local directory and a bucket."""
+    api = get_hf_api(token=token)
+    api.sync_bucket(
+        source=source,
+        dest=dest,
+        delete=delete,
+        ignore_times=ignore_times,
+        ignore_sizes=ignore_sizes,
+        existing=existing,
+        ignore_existing=ignore_existing,
+        include=include,
+        exclude=exclude,
+        filter_from=filter_from,
+        plan=plan,
+        apply=apply,
+        dry_run=dry_run,
+        verbose=verbose,
+        quiet=out.is_quiet(),
+    )
+    if plan and not out.is_quiet():
+        out.hint(f"Run `hf buckets sync --apply {plan}` to execute this plan.")
+
+
+# =============================================================================
+# Cp command
+# =============================================================================
+
+
+@buckets_cli.command(
+    name="cp",
+    examples=[
+        "hf buckets cp hf://buckets/user/my-bucket/config.json",
+        "hf buckets cp hf://buckets/user/my-bucket/config.json ./data/",
+        "hf buckets cp hf://buckets/user/my-bucket/config.json my-config.json",
+        "hf buckets cp hf://buckets/user/my-bucket/config.json -",
+        "hf buckets cp my-config.json hf://buckets/user/my-bucket",
+        "hf buckets cp my-config.json hf://buckets/user/my-bucket/logs/",
+        "hf buckets cp my-config.json hf://buckets/user/my-bucket/remote-config.json",
+        "hf buckets cp - hf://buckets/user/my-bucket/config.json",
+        "hf buckets cp hf://buckets/user/my-bucket/logs hf://buckets/user/archive-bucket/  # nests logs/ dir",
+        "hf buckets cp hf://buckets/user/my-bucket/logs/ hf://buckets/user/archive-bucket/  # copies contents only",
+        "hf buckets cp hf://datasets/user/my-dataset/processed/ hf://buckets/user/my-bucket/dataset/processed/",
+    ],
+)
+def cp(
+    src: Annotated[
+        str, typer.Argument(help="Source: local file, any hf:// handle (model, dataset, bucket), or - for stdin")
+    ],
+    dst: Annotated[
+        str | None, typer.Argument(help="Destination: local path, bucket hf://... handle, or - for stdout")
+    ] = None,
+    token: TokenOpt = None,
+) -> None:
+    """Copy files to or from buckets."""
+    api = get_hf_api(token=token)
+
+    src_is_hf = _is_hf_handle(src)
+    dst_is_hf = dst is not None and _is_hf_handle(dst)
+    src_is_bucket = _is_bucket_path(src)
+    dst_is_bucket = dst is not None and _is_bucket_path(dst)
+    src_is_stdin = src == "-"
+    dst_is_stdout = dst == "-"
+
+    # Remote to remote copy
+    if src_is_hf and dst_is_hf:
+        try:
+            api.copy_files(src, dst)  # type: ignore
+        except ValueError as e:
+            raise typer.BadParameter(str(e))
+
+        out.result("Copied", src=src, dst=dst)
+        return
+
+    # Local to remote copy
+    # --- Validation ---
+    if not src_is_bucket and not dst_is_bucket and not src_is_stdin:
+        if dst is None:
+            raise typer.BadParameter("Missing destination. Provide a bucket path as DST.")
+        raise typer.BadParameter("One of SRC or DST must be a bucket path (hf://buckets/...).")
+
+    if src_is_stdin and not dst_is_bucket:
+        raise typer.BadParameter("Stdin upload requires a bucket destination.")
+
+    if src_is_stdin and dst_is_bucket:
+        _, prefix = _parse_bucket_path(dst)  # type: ignore
+        if prefix == "" or prefix.endswith("/"):
+            raise typer.BadParameter("Stdin upload requires a full destination path including filename.")
+
+    if dst_is_stdout and not src_is_bucket:
+        raise typer.BadParameter("Cannot pipe to stdout for uploads.")
+
+    if not src_is_bucket and not src_is_stdin and os.path.isdir(src):
+        raise typer.BadParameter("Source must be a file, not a directory. Use `hf buckets sync` for directories.")
+
+    # --- Determine direction and execute ---
+    if src_is_bucket:
+        # Download: remote -> local or stdout
+        bucket_id, prefix = _parse_bucket_path(src)
+        if prefix == "" or prefix.endswith("/"):
+            raise typer.BadParameter("Source path must include a file name, not just a bucket or directory path.")
+        filename = prefix.rsplit("/", 1)[-1]
+
+        if dst_is_stdout:
+            # Download to stdout: always suppress progress bars to avoid polluting output
+            # Only re-enable if they weren't already disabled by the caller
+            with disable_progress_bars():
+                with SoftTemporaryDirectory() as tmp_dir:
+                    tmp_path = os.path.join(tmp_dir, filename)
+                    api.download_bucket_files(bucket_id, [(prefix, tmp_path)])
+                    with open(tmp_path, "rb") as f:
+                        while chunk := f.read(32_000_000):  # 32MB chunks
+                            sys.stdout.buffer.write(chunk)
+        else:
+            # Download to file
+            if dst is None:
+                local_path = filename
+            elif os.path.isdir(dst) or dst.endswith(os.sep) or dst.endswith("/"):
+                local_path = os.path.join(dst, filename)
+            else:
+                local_path = dst
+
+            # Ensure parent directory exists
+            parent_dir = os.path.dirname(local_path)
+            if parent_dir:
+                os.makedirs(parent_dir, exist_ok=True)
+
+            api.download_bucket_files(bucket_id, [(prefix, local_path)])
+            out.result("Downloaded", src=src, dst=local_path)
+
+    elif src_is_stdin:
+        # Upload from stdin
+        bucket_id, remote_path = _parse_bucket_path(dst)  # type: ignore
+        data = sys.stdin.buffer.read()
+
+        api.batch_bucket_files(bucket_id, add=[(data, remote_path)])
+        out.result("Uploaded", src="stdin", dst=dst)
+
+    else:
+        # Upload from file
+        if not os.path.isfile(src):
+            raise typer.BadParameter(f"Source file not found: {src}")
+
+        bucket_id, prefix = _parse_bucket_path(dst)  # type: ignore
+
+        if prefix == "":
+            remote_path = os.path.basename(src)
+        elif prefix.endswith("/"):
+            remote_path = prefix + os.path.basename(src)
+        else:
+            remote_path = prefix
+
+        api.batch_bucket_files(bucket_id, add=[(src, remote_path)])
+        out.result("Uploaded", src=src, dst=f"{BUCKET_PREFIX}{bucket_id}/{remote_path}")

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/cli/cache.py

@@ -0,0 +1,752 @@
+# Copyright 2025-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains the 'hf cache' command group with cache management subcommands."""
+
+import re
+import time
+from collections import defaultdict
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from enum import Enum
+from typing import Annotated, Any
+
+import typer
+
+from huggingface_hub.errors import CLIError
+
+from ..utils import ANSI, CachedRepoInfo, CachedRevisionInfo, CacheNotFound, HFCacheInfo, _format_size, scan_cache_dir
+from ..utils._parsing import parse_duration, parse_size
+from ._cli_utils import RepoIdArg, RepoTypeOpt, RevisionOpt, TokenOpt, get_hf_api, typer_factory
+from ._output import out
+
+
+cache_cli = typer_factory(help="Manage local cache directory.")
+
+
+#### Cache helper utilities
+
+
+@dataclass(frozen=True)
+class _DeletionResolution:
+    revisions: frozenset[str]
+    selected: dict[CachedRepoInfo, frozenset[CachedRevisionInfo]]
+    missing: tuple[str, ...]
+
+
+_FILTER_PATTERN = re.compile(r"^(?P<key>[a-zA-Z_]+)\s*(?P<op>==|!=|>=|<=|>|<|=)\s*(?P<value>.+)$")
+_ALLOWED_OPERATORS = {"=", "!=", ">", "<", ">=", "<="}
+_FILTER_KEYS = {"accessed", "modified", "refs", "size", "type"}
+_SORT_KEYS = {"accessed", "modified", "name", "size"}
+_SORT_PATTERN = re.compile(r"^(?P<key>[a-zA-Z_]+)(?::(?P<order>asc|desc))?$")
+_SORT_DEFAULT_ORDER = {
+    # Default ordering: accessed/modified/size are descending (newest/biggest first), name is ascending
+    "accessed": "desc",
+    "modified": "desc",
+    "size": "desc",
+    "name": "asc",
+}
+
+
+# Dynamically generate SortOptions enum from _SORT_KEYS
+_sort_options_dict = {}
+for key in sorted(_SORT_KEYS):
+    _sort_options_dict[key] = key
+    _sort_options_dict[f"{key}_asc"] = f"{key}:asc"
+    _sort_options_dict[f"{key}_desc"] = f"{key}:desc"
+
+SortOptions = Enum("SortOptions", _sort_options_dict, type=str, module=__name__)  # type: ignore
+
+
+@dataclass(frozen=True)
+class CacheDeletionCounts:
+    """Simple counters summarizing cache deletions for CLI messaging."""
+
+    repo_count: int
+    partial_revision_count: int
+    total_revision_count: int
+
+
+CacheEntry = tuple[CachedRepoInfo, CachedRevisionInfo | None]
+RepoRefsMap = dict[CachedRepoInfo, frozenset[str]]
+
+
+def summarize_deletions(
+    selected_by_repo: Mapping[CachedRepoInfo, frozenset[CachedRevisionInfo]],
+) -> CacheDeletionCounts:
+    """Summarize deletions across repositories."""
+    repo_count = 0
+    total_revisions = 0
+    revisions_in_full_repos = 0
+
+    for repo, revisions in selected_by_repo.items():
+        total_revisions += len(revisions)
+        if len(revisions) == len(repo.revisions):
+            repo_count += 1
+            revisions_in_full_repos += len(revisions)
+
+    partial_revision_count = total_revisions - revisions_in_full_repos
+    return CacheDeletionCounts(repo_count, partial_revision_count, total_revisions)
+
+
+def print_cache_selected_revisions(selected_by_repo: Mapping[CachedRepoInfo, frozenset[CachedRevisionInfo]]) -> None:
+    """Pretty-print selected cache revisions during confirmation prompts."""
+    for repo in sorted(selected_by_repo.keys(), key=lambda repo: (repo.repo_type, repo.repo_id.lower())):
+        repo_key = f"{repo.repo_type}/{repo.repo_id}"
+        revisions = sorted(selected_by_repo[repo], key=lambda rev: rev.commit_hash)
+        if len(revisions) == len(repo.revisions):
+            out.text(f"  - {repo_key} (entire repo)")
+            continue
+
+        out.text(f"  - {repo_key}:")
+        for revision in revisions:
+            refs = " ".join(sorted(revision.refs)) or "(detached)"
+            out.text(f"      {revision.commit_hash} [{refs}] {revision.size_on_disk_str}")
+
+
+def build_cache_index(
+    hf_cache_info: HFCacheInfo,
+) -> tuple[
+    dict[str, CachedRepoInfo],
+    dict[str, tuple[CachedRepoInfo, CachedRevisionInfo]],
+]:
+    """Create lookup tables so CLI commands can resolve repo ids and revisions quickly."""
+    repo_lookup: dict[str, CachedRepoInfo] = {}
+    revision_lookup: dict[str, tuple[CachedRepoInfo, CachedRevisionInfo]] = {}
+    for repo in hf_cache_info.repos:
+        repo_key = repo.cache_id.lower()
+        repo_lookup[repo_key] = repo
+        for revision in repo.revisions:
+            revision_lookup[revision.commit_hash.lower()] = (repo, revision)
+    return repo_lookup, revision_lookup
+
+
+def collect_cache_entries(
+    hf_cache_info: HFCacheInfo, *, include_revisions: bool
+) -> tuple[list[CacheEntry], RepoRefsMap]:
+    """Flatten cache metadata into rows consumed by `hf cache ls`."""
+    entries: list[CacheEntry] = []
+    repo_refs_map: RepoRefsMap = {}
+    sorted_repos = sorted(hf_cache_info.repos, key=lambda repo: (repo.repo_type, repo.repo_id.lower()))
+    for repo in sorted_repos:
+        repo_refs_map[repo] = frozenset({ref for revision in repo.revisions for ref in revision.refs})
+        if include_revisions:
+            for revision in sorted(repo.revisions, key=lambda rev: rev.commit_hash):
+                entries.append((repo, revision))
+        else:
+            entries.append((repo, None))
+    if include_revisions:
+        entries.sort(
+            key=lambda entry: (
+                entry[0].cache_id,
+                entry[1].commit_hash if entry[1] is not None else "",
+            )
+        )
+    else:
+        entries.sort(key=lambda entry: entry[0].cache_id)
+    return entries, repo_refs_map
+
+
+def compile_cache_filter(
+    expr: str, repo_refs_map: RepoRefsMap
+) -> Callable[[CachedRepoInfo, CachedRevisionInfo | None, float], bool]:
+    """Convert a `hf cache ls` filter expression into the yes/no test we apply to each cache entry before displaying it."""
+    match = _FILTER_PATTERN.match(expr.strip())
+    if not match:
+        raise ValueError(f"Invalid filter expression: '{expr}'.")
+
+    key = match.group("key").lower()
+    op = match.group("op")
+    value_raw = match.group("value").strip()
+
+    if op not in _ALLOWED_OPERATORS:
+        raise ValueError(f"Unsupported operator '{op}' in filter '{expr}'. Must be one of {list(_ALLOWED_OPERATORS)}.")
+
+    if key not in _FILTER_KEYS:
+        raise ValueError(f"Unsupported filter key '{key}' in '{expr}'. Must be one of {list(_FILTER_KEYS)}.")
+    # at this point we know that key is in `_FILTER_KEYS`
+    if key == "size":
+        size_threshold = parse_size(value_raw)
+        return lambda repo, revision, _: _compare_numeric(
+            revision.size_on_disk if revision is not None else repo.size_on_disk,
+            op,
+            size_threshold,
+        )
+
+    if key in {"modified", "accessed"}:
+        seconds = parse_duration(value_raw.strip())
+
+        def _time_filter(repo: CachedRepoInfo, revision: CachedRevisionInfo | None, now: float) -> bool:
+            timestamp = (
+                repo.last_accessed
+                if key == "accessed"
+                else revision.last_modified
+                if revision is not None
+                else repo.last_modified
+            )
+            if timestamp is None:
+                return False
+            return _compare_numeric(now - timestamp, op, seconds)
+
+        return _time_filter
+
+    if key == "type":
+        expected = value_raw.lower()
+
+        if op != "=":
+            raise ValueError(f"Only '=' is supported for 'type' filters. Got '{op}'.")
+
+        def _type_filter(repo: CachedRepoInfo, revision: CachedRevisionInfo | None, _: float) -> bool:
+            return repo.repo_type.lower() == expected
+
+        return _type_filter
+
+    else:  # key == "refs"
+        if op != "=":
+            raise ValueError(f"Only '=' is supported for 'refs' filters. Got {op}.")
+
+        def _refs_filter(repo: CachedRepoInfo, revision: CachedRevisionInfo | None, _: float) -> bool:
+            refs = revision.refs if revision is not None else repo_refs_map.get(repo, frozenset())
+            return value_raw.lower() in [ref.lower() for ref in refs]
+
+        return _refs_filter
+
+
+def _compare_numeric(left: float | None, op: str, right: float) -> bool:
+    """Evaluate numeric comparisons for filters."""
+    if left is None:
+        return False
+
+    comparisons = {
+        "=": left == right,
+        "!=": left != right,
+        ">": left > right,
+        "<": left < right,
+        ">=": left >= right,
+        "<=": left <= right,
+    }
+
+    if op not in comparisons:
+        raise ValueError(f"Unsupported numeric comparison operator: {op}")
+
+    return comparisons[op]
+
+
+def compile_cache_sort(sort_expr: str) -> tuple[Callable[[CacheEntry], tuple[Any, ...]], bool]:
+    """Convert a `hf cache ls` sort expression into a key function for sorting entries.
+
+    Returns:
+        A tuple of (key_function, reverse_flag) where reverse_flag indicates whether
+        to sort in descending order (True) or ascending order (False).
+    """
+    match = _SORT_PATTERN.match(sort_expr.strip().lower())
+    if not match:
+        raise ValueError(f"Invalid sort expression: '{sort_expr}'. Expected format: 'key' or 'key:asc' or 'key:desc'.")
+
+    key = match.group("key").lower()
+    explicit_order = match.group("order")
+
+    if key not in _SORT_KEYS:
+        raise ValueError(f"Unsupported sort key '{key}' in '{sort_expr}'. Must be one of {list(_SORT_KEYS)}.")
+
+    # Use explicit order if provided, otherwise use default for the key
+    order = explicit_order if explicit_order else _SORT_DEFAULT_ORDER[key]
+    reverse = order == "desc"
+
+    def _sort_key(entry: CacheEntry) -> tuple[Any, ...]:
+        repo, revision = entry
+
+        if key == "name":
+            # Sort by cache_id (repo type/id)
+            value: Any = repo.cache_id.lower()
+            return (value,)
+
+        if key == "size":
+            # Use revision size if available, otherwise repo size
+            value = revision.size_on_disk if revision is not None else repo.size_on_disk
+            return (value,)
+
+        if key == "accessed":
+            # For revisions, accessed is not available per-revision, use repo's last_accessed
+            # For repos, use repo's last_accessed
+            value = repo.last_accessed if repo.last_accessed is not None else 0.0
+            return (value,)
+
+        if key == "modified":
+            # Use revision's last_modified if available, otherwise repo's last_modified
+            if revision is not None:
+                value = revision.last_modified if revision.last_modified is not None else 0.0
+            else:
+                value = repo.last_modified if repo.last_modified is not None else 0.0
+            return (value,)
+
+        # Should never reach here due to validation above
+        raise ValueError(f"Unsupported sort key: {key}")
+
+    return _sort_key, reverse
+
+
+def _resolve_deletion_targets(hf_cache_info: HFCacheInfo, targets: list[str]) -> _DeletionResolution:
+    """Resolve the deletion targets into a deletion resolution."""
+    repo_lookup, revision_lookup = build_cache_index(hf_cache_info)
+
+    selected: dict[CachedRepoInfo, set[CachedRevisionInfo]] = defaultdict(set)
+    revisions: set[str] = set()
+    missing: list[str] = []
+
+    for raw_target in targets:
+        target = raw_target.strip()
+        if not target:
+            continue
+        lowered = target.lower()
+
+        if re.fullmatch(r"[0-9a-fA-F]{40}", lowered):
+            match = revision_lookup.get(lowered)
+            if match is None:
+                missing.append(raw_target)
+                continue
+            repo, revision = match
+            selected[repo].add(revision)
+            revisions.add(revision.commit_hash)
+            continue
+
+        matched_repo = repo_lookup.get(lowered)
+        if matched_repo is None:
+            missing.append(raw_target)
+            continue
+
+        for revision in matched_repo.revisions:
+            selected[matched_repo].add(revision)
+            revisions.add(revision.commit_hash)
+
+    frozen_selected = {repo: frozenset(revs) for repo, revs in selected.items()}
+    return _DeletionResolution(
+        revisions=frozenset(revisions),
+        selected=frozen_selected,
+        missing=tuple(missing),
+    )
+
+
+#### Cache CLI commands
+
+
+@cache_cli.command(
+    "list | ls",
+    examples=[
+        "hf cache ls",
+        "hf cache ls --revisions",
+        'hf cache ls --filter "size>1GB" --limit 20',
+        "hf cache ls --format json",
+    ],
+)
+def ls(
+    cache_dir: Annotated[
+        str | None,
+        typer.Option(
+            help="Cache directory to scan (defaults to Hugging Face cache).",
+        ),
+    ] = None,
+    revisions: Annotated[
+        bool,
+        typer.Option(
+            help="Include revisions in the output instead of aggregated repositories.",
+        ),
+    ] = False,
+    filter: Annotated[
+        list[str] | None,
+        typer.Option(
+            "-f",
+            "--filter",
+            help="Filter entries (e.g. 'size>1GB', 'type=model', 'accessed>7d'). Can be used multiple times.",
+        ),
+    ] = None,
+    sort: Annotated[
+        SortOptions | None,
+        typer.Option(
+            help="Sort entries by key. Supported keys: 'accessed', 'modified', 'name', 'size'. "
+            "Append ':asc' or ':desc' to explicitly set the order (e.g., 'modified:asc'). "
+            "Defaults: 'accessed', 'modified', 'size' default to 'desc' (newest/biggest first); "
+            "'name' defaults to 'asc' (alphabetical).",
+        ),
+    ] = None,
+    limit: Annotated[
+        int | None,
+        typer.Option(
+            help="Limit the number of results returned. Returns only the top N entries after sorting.",
+        ),
+    ] = None,
+) -> None:
+    """List cached repositories or revisions."""
+    try:
+        hf_cache_info = scan_cache_dir(cache_dir)
+    except CacheNotFound as exc:
+        raise CLIError(f"Cache directory not found: {exc.cache_dir}") from exc
+
+    filters = filter or []
+
+    entries, repo_refs_map = collect_cache_entries(hf_cache_info, include_revisions=revisions)
+    try:
+        filter_fns = [compile_cache_filter(expr, repo_refs_map) for expr in filters]
+    except ValueError as exc:
+        raise typer.BadParameter(str(exc)) from exc
+
+    now = time.time()
+    for fn in filter_fns:
+        entries = [entry for entry in entries if fn(entry[0], entry[1], now)]
+
+    # Apply sorting if requested
+    if sort:
+        try:
+            sort_key_fn, reverse = compile_cache_sort(sort.value)
+            entries.sort(key=sort_key_fn, reverse=reverse)
+        except ValueError as exc:
+            raise typer.BadParameter(str(exc)) from exc
+
+    # Apply limit if requested
+    if limit is not None:
+        if limit < 0:
+            raise typer.BadParameter(f"Limit must be a positive integer, got {limit}.")
+        entries = entries[:limit]
+
+    if revisions:
+        items = [
+            {
+                "id": repo.cache_id,
+                "repo_id": repo.repo_id,
+                "repo_type": repo.repo_type,
+                "revision": revision.commit_hash,
+                "snapshot_path": str(revision.snapshot_path),
+                "size": revision.size_on_disk_str,
+                "last_modified": revision.last_modified_str,
+                "refs": sorted(revision.refs),
+            }
+            for repo, revision in entries
+            if revision is not None
+        ]
+        out.table(
+            items,
+            headers=["id", "revision", "size", "last_modified", "refs"],
+            id_key="revision",
+            alignments={"size": "right"},
+        )
+    else:
+        items = [
+            {
+                "id": repo.cache_id,
+                "repo_id": repo.repo_id,
+                "repo_type": repo.repo_type,
+                "size": repo.size_on_disk_str,
+                "last_accessed": repo.last_accessed_str or "",
+                "last_modified": repo.last_modified_str,
+                "refs": sorted(repo_refs_map.get(repo, frozenset())),
+            }
+            for repo, _ in entries
+        ]
+        out.table(
+            items,
+            headers=["id", "size", "last_accessed", "last_modified", "refs"],
+            id_key="id",
+            alignments={"size": "right"},
+        )
+
+    if entries:
+        unique_repos = {repo for repo, _ in entries}
+        repo_count = len(unique_repos)
+        if revisions:
+            revision_count = sum(1 for _, rev in entries if rev is not None)
+            total_size = sum(rev.size_on_disk for _, rev in entries if rev is not None)
+        else:
+            revision_count = sum(len(repo.revisions) for repo in unique_repos)
+            total_size = sum(repo.size_on_disk for repo in unique_repos)
+        out.text(
+            ANSI.bold(
+                f"\nFound {repo_count} repo(s) for a total of {revision_count} revision(s)"
+                f" and {_format_size(total_size)} on disk."
+            )
+        )
+
+
+@cache_cli.command(
+    examples=[
+        "hf cache rm model/gpt2",
+        "hf cache rm <revision_hash>",
+        "hf cache rm model/gpt2 --dry-run",
+        "hf cache rm model/gpt2 --yes",
+    ],
+)
+def rm(
+    targets: Annotated[
+        list[str],
+        typer.Argument(
+            help="One or more repo IDs (e.g. model/bert-base-uncased) or revision hashes to delete.",
+        ),
+    ],
+    cache_dir: Annotated[
+        str | None,
+        typer.Option(
+            help="Cache directory to scan (defaults to Hugging Face cache).",
+        ),
+    ] = None,
+    yes: Annotated[
+        bool,
+        typer.Option(
+            "-y",
+            "--yes",
+            help="Skip confirmation prompt.",
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            help="Preview deletions without removing anything.",
+        ),
+    ] = False,
+) -> None:
+    """Remove cached repositories or revisions."""
+    try:
+        hf_cache_info = scan_cache_dir(cache_dir)
+    except CacheNotFound as exc:
+        raise CLIError(f"Cache directory not found: {exc.cache_dir}") from exc
+
+    resolution = _resolve_deletion_targets(hf_cache_info, targets)
+
+    if resolution.missing:
+        details = "\n".join(f"  - {entry}" for entry in resolution.missing)
+        out.warning(f"Could not find in cache:\n{details}")
+
+    if len(resolution.revisions) == 0:
+        out.text("Nothing to delete.")
+        raise typer.Exit(code=0)
+
+    strategy = hf_cache_info.delete_revisions(*sorted(resolution.revisions))
+    counts = summarize_deletions(resolution.selected)
+
+    summary_parts: list[str] = []
+    if counts.repo_count:
+        summary_parts.append(f"{counts.repo_count} repo(s)")
+    if counts.partial_revision_count:
+        summary_parts.append(f"{counts.partial_revision_count} revision(s)")
+    if not summary_parts:
+        summary_parts.append(f"{counts.total_revision_count} revision(s)")
+
+    summary_text = " and ".join(summary_parts)
+    out.text(f"About to delete {summary_text} totalling {strategy.expected_freed_size_str}.")
+    print_cache_selected_revisions(resolution.selected)
+
+    if dry_run:
+        out.result(
+            "Dry run: no files were deleted.",
+            dry_run=True,
+            repos=counts.repo_count,
+            revisions=counts.total_revision_count,
+            size=strategy.expected_freed_size_str,
+        )
+        return
+
+    out.confirm("Proceed with deletion?", yes=yes)
+
+    strategy.execute()
+    counts = summarize_deletions(resolution.selected)
+    out.result(
+        f"Deleted {counts.repo_count} repo(s) and {counts.total_revision_count} revision(s);"
+        f" freed {strategy.expected_freed_size_str}.",
+        repos_deleted=counts.repo_count,
+        revisions_deleted=counts.total_revision_count,
+        freed=strategy.expected_freed_size_str,
+    )
+
+
+@cache_cli.command(examples=["hf cache prune", "hf cache prune --dry-run"])
+def prune(
+    cache_dir: Annotated[
+        str | None,
+        typer.Option(
+            help="Cache directory to scan (defaults to Hugging Face cache).",
+        ),
+    ] = None,
+    yes: Annotated[
+        bool,
+        typer.Option(
+            "-y",
+            "--yes",
+            help="Skip confirmation prompt.",
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            help="Preview deletions without removing anything.",
+        ),
+    ] = False,
+) -> None:
+    """Remove detached revisions from the cache."""
+    try:
+        hf_cache_info = scan_cache_dir(cache_dir)
+    except CacheNotFound as exc:
+        raise CLIError(f"Cache directory not found: {exc.cache_dir}") from exc
+
+    selected: dict[CachedRepoInfo, frozenset[CachedRevisionInfo]] = {}
+    revisions: set[str] = set()
+    for repo in hf_cache_info.repos:
+        detached = frozenset(revision for revision in repo.revisions if len(revision.refs) == 0)
+        if not detached:
+            continue
+        selected[repo] = detached
+        revisions.update(revision.commit_hash for revision in detached)
+
+    if len(revisions) == 0:
+        out.text("No unreferenced revisions found. Nothing to prune.")
+        return
+
+    resolution = _DeletionResolution(
+        revisions=frozenset(revisions),
+        selected=selected,
+        missing=(),
+    )
+    strategy = hf_cache_info.delete_revisions(*sorted(resolution.revisions))
+    counts = summarize_deletions(selected)
+
+    out.text(
+        f"About to delete {counts.total_revision_count} unreferenced revision(s) ({strategy.expected_freed_size_str} total)."
+    )
+    print_cache_selected_revisions(selected)
+
+    if dry_run:
+        out.result(
+            "Dry run: no files were deleted.",
+            dry_run=True,
+            revisions=counts.total_revision_count,
+            size=strategy.expected_freed_size_str,
+        )
+        return
+
+    out.confirm("Proceed?", yes=yes)
+
+    strategy.execute()
+    out.result(
+        f"Deleted {counts.total_revision_count} unreferenced revision(s); freed {strategy.expected_freed_size_str}.",
+        revisions_deleted=counts.total_revision_count,
+        freed=strategy.expected_freed_size_str,
+    )
+
+
+@cache_cli.command(
+    examples=[
+        "hf cache verify gpt2",
+        "hf cache verify gpt2 --revision refs/pr/1",
+        "hf cache verify my-dataset --repo-type dataset",
+    ],
+)
+def verify(
+    repo_id: RepoIdArg,
+    repo_type: RepoTypeOpt = RepoTypeOpt.model,
+    revision: RevisionOpt = None,
+    cache_dir: Annotated[
+        str | None,
+        typer.Option(
+            help="Cache directory to use when verifying files from cache (defaults to Hugging Face cache).",
+        ),
+    ] = None,
+    local_dir: Annotated[
+        str | None,
+        typer.Option(
+            help="If set, verify files under this directory instead of the cache.",
+        ),
+    ] = None,
+    fail_on_missing_files: Annotated[
+        bool,
+        typer.Option(
+            "--fail-on-missing-files",
+            help="Fail if some files exist on the remote but are missing locally.",
+        ),
+    ] = False,
+    fail_on_extra_files: Annotated[
+        bool,
+        typer.Option(
+            "--fail-on-extra-files",
+            help="Fail if some files exist locally but are not present on the remote revision.",
+        ),
+    ] = False,
+    token: TokenOpt = None,
+) -> None:
+    """Verify checksums for a single repo revision from cache or a local directory.
+
+    Examples:
+      - Verify main revision in cache: `hf cache verify gpt2`
+      - Verify specific revision: `hf cache verify gpt2 --revision refs/pr/1`
+      - Verify dataset: `hf cache verify karpathy/fineweb-edu-100b-shuffle --repo-type dataset`
+      - Verify local dir: `hf cache verify deepseek-ai/DeepSeek-OCR --local-dir /path/to/repo`
+    """
+
+    if local_dir is not None and cache_dir is not None:
+        out.error("Cannot pass both --local-dir and --cache-dir. Use one or the other.")
+        raise typer.Exit(code=2)
+
+    api = get_hf_api(token=token)
+
+    result = api.verify_repo_checksums(
+        repo_id=repo_id,
+        repo_type=repo_type.value if hasattr(repo_type, "value") else str(repo_type),
+        revision=revision,
+        local_dir=local_dir,
+        cache_dir=cache_dir,
+        token=token,
+    )
+
+    exit_code = 0
+
+    if result.mismatches:
+        details = "\n".join(
+            f"  - {m['path']}: expected {m['expected']} ({m['algorithm']}), got {m['actual']}"
+            for m in result.mismatches
+        )
+        out.text(f"❌ Checksum verification failed for the following file(s):\n{details}")
+        exit_code = 1
+
+    if result.missing_paths:
+        if fail_on_missing_files:
+            details = "\n".join(f"  - {p}" for p in result.missing_paths)
+            out.text(f"❌ Missing files (present remotely, absent locally):\n{details}")
+            exit_code = 1
+        else:
+            out.warning(
+                f"{len(result.missing_paths)} remote file(s) are missing locally. "
+                "Use --fail-on-missing-files for details."
+            )
+
+    if result.extra_paths:
+        if fail_on_extra_files:
+            details = "\n".join(f"  - {p}" for p in result.extra_paths)
+            out.text(f"❌ Extra files (present locally, absent remotely):\n{details}")
+            exit_code = 1
+        else:
+            out.warning(
+                f"{len(result.extra_paths)} local file(s) do not exist on the remote repo. "
+                "Use --fail-on-extra-files for details."
+            )
+
+    verified_location = result.verified_path
+
+    if exit_code != 0:
+        out.error(
+            f"Verification failed for '{repo_id}' ({repo_type.value}) in {verified_location}.\n  Revision: {result.revision}"
+        )
+        raise typer.Exit(code=exit_code)
+
+    out.result(
+        f"Verified {result.checked_count} file(s) for {repo_type.value} '{repo_id}'. All checksums match.",
+        repo_id=repo_id,
+        repo_type=repo_type.value,
+        checked=result.checked_count,
+        path=str(verified_location),
+    )

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/cli/collections.py

@@ -0,0 +1,316 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains commands to interact with collections on the Hugging Face Hub.
+
+Usage:
+    # list collections on the Hub
+    hf collections ls
+
+    # list collections for a specific user
+    hf collections ls --owner username
+
+    # get info about a collection
+    hf collections info username/collection-slug
+
+    # create a new collection
+    hf collections create "My Collection" --description "A collection of models"
+
+    # add an item to a collection
+    hf collections add-item username/collection-slug username/model-name model
+
+    # delete a collection
+    hf collections delete username/collection-slug
+"""
+
+import enum
+from typing import Annotated, get_args
+
+import typer
+
+from huggingface_hub.hf_api import CollectionItemType_T, CollectionSort_T
+
+from ._cli_utils import LimitOpt, TokenOpt, api_object_to_dict, get_hf_api, typer_factory
+from ._output import out
+
+
+# Build enums dynamically from Literal types to avoid duplication
+_COLLECTION_ITEM_TYPES = get_args(CollectionItemType_T)
+CollectionItemType = enum.Enum("CollectionItemType", {t: t for t in _COLLECTION_ITEM_TYPES}, type=str)  # type: ignore[misc]
+
+_COLLECTION_SORT_OPTIONS = get_args(CollectionSort_T)
+CollectionSort = enum.Enum("CollectionSort", {s: s for s in _COLLECTION_SORT_OPTIONS}, type=str)  # type: ignore[misc]
+
+
+collections_cli = typer_factory(help="Interact with collections on the Hub.")
+
+
+@collections_cli.command(
+    "list | ls",
+    examples=[
+        "hf collections ls",
+        "hf collections ls --owner nvidia",
+        "hf collections ls --item models/teknium/OpenHermes-2.5-Mistral-7B --limit 10",
+    ],
+)
+def collections_ls(
+    owner: Annotated[
+        str | None,
+        typer.Option(help="Filter by owner username or organization."),
+    ] = None,
+    item: Annotated[
+        str | None,
+        typer.Option(
+            help='Filter collections containing a specific item (e.g., "models/gpt2", "datasets/squad", "papers/2311.12983").'
+        ),
+    ] = None,
+    sort: Annotated[
+        CollectionSort | None,
+        typer.Option(help="Sort results by last modified, trending, or upvotes."),
+    ] = None,
+    limit: LimitOpt = 10,
+    token: TokenOpt = None,
+) -> None:
+    """List collections on the Hub."""
+    api = get_hf_api(token=token)
+    sort_key = sort.value if sort else None
+    results = [
+        api_object_to_dict(collection)
+        for collection in api.list_collections(
+            owner=owner,
+            item=item,
+            sort=sort_key,  # type: ignore[arg-type]
+            limit=limit,
+        )
+    ]
+    out.table(results)
+
+
+@collections_cli.command(
+    "info",
+    examples=[
+        "hf collections info username/my-collection-slug",
+    ],
+)
+def collections_info(
+    collection_slug: Annotated[str, typer.Argument(help="The collection slug (e.g., 'username/collection-slug').")],
+    token: TokenOpt = None,
+) -> None:
+    """Get info about a collection on the Hub."""
+    api = get_hf_api(token=token)
+    collection = api.get_collection(collection_slug)
+    out.dict(collection)
+
+
+@collections_cli.command(
+    "create",
+    examples=[
+        'hf collections create "My Models"',
+        'hf collections create "My Models" --description "A collection of my favorite models" --private',
+        'hf collections create "Org Collection" --namespace my-org',
+    ],
+)
+def collections_create(
+    title: Annotated[str, typer.Argument(help="The title of the collection.")],
+    namespace: Annotated[
+        str | None,
+        typer.Option(help="The namespace (username or organization). Defaults to the authenticated user."),
+    ] = None,
+    description: Annotated[
+        str | None,
+        typer.Option(help="A description for the collection."),
+    ] = None,
+    private: Annotated[
+        bool,
+        typer.Option(help="Create a private collection."),
+    ] = False,
+    exists_ok: Annotated[
+        bool,
+        typer.Option(help="Do not raise an error if the collection already exists."),
+    ] = False,
+    token: TokenOpt = None,
+) -> None:
+    """Create a new collection on the Hub."""
+    api = get_hf_api(token=token)
+    collection = api.create_collection(
+        title=title,
+        namespace=namespace,
+        description=description,
+        private=private,
+        exists_ok=exists_ok,
+    )
+    out.result("Collection created", slug=collection.slug, url=collection.url)
+
+
+@collections_cli.command(
+    "update",
+    examples=[
+        'hf collections update username/my-collection --title "New Title"',
+        'hf collections update username/my-collection --description "Updated description"',
+        "hf collections update username/my-collection --private --theme green",
+    ],
+)
+def collections_update(
+    collection_slug: Annotated[str, typer.Argument(help="The collection slug (e.g., 'username/collection-slug').")],
+    title: Annotated[
+        str | None,
+        typer.Option(help="The new title for the collection."),
+    ] = None,
+    description: Annotated[
+        str | None,
+        typer.Option(help="The new description for the collection."),
+    ] = None,
+    position: Annotated[
+        int | None,
+        typer.Option(help="The new position of the collection in the owner's list."),
+    ] = None,
+    private: Annotated[
+        bool | None,
+        typer.Option(help="Whether the collection should be private."),
+    ] = None,
+    theme: Annotated[
+        str | None,
+        typer.Option(help="The theme color for the collection (e.g., 'green', 'blue')."),
+    ] = None,
+    token: TokenOpt = None,
+) -> None:
+    """Update a collection's metadata on the Hub."""
+    api = get_hf_api(token=token)
+    collection = api.update_collection_metadata(
+        collection_slug=collection_slug,
+        title=title,
+        description=description,
+        position=position,
+        private=private,
+        theme=theme,
+    )
+    out.result("Collection updated", slug=collection.slug, url=collection.url)
+
+
+@collections_cli.command(
+    "delete",
+    examples=[
+        "hf collections delete username/my-collection",
+        "hf collections delete username/my-collection --missing-ok",
+    ],
+)
+def collections_delete(
+    collection_slug: Annotated[str, typer.Argument(help="The collection slug (e.g., 'username/collection-slug').")],
+    missing_ok: Annotated[
+        bool,
+        typer.Option(help="Do not raise an error if the collection doesn't exist."),
+    ] = False,
+    token: TokenOpt = None,
+) -> None:
+    """Delete a collection from the Hub."""
+    api = get_hf_api(token=token)
+    api.delete_collection(collection_slug, missing_ok=missing_ok)
+    out.result("Collection deleted", slug=collection_slug)
+
+
+@collections_cli.command(
+    "add-item",
+    examples=[
+        "hf collections add-item username/my-collection moonshotai/kimi-k2 model",
+        'hf collections add-item username/my-collection Qwen/DeepPlanning dataset --note "Useful dataset"',
+        "hf collections add-item username/my-collection Tongyi-MAI/Z-Image space",
+    ],
+)
+def collections_add_item(
+    collection_slug: Annotated[str, typer.Argument(help="The collection slug (e.g., 'username/collection-slug').")],
+    item_id: Annotated[
+        str, typer.Argument(help="The ID of the item to add (repo_id for repos, paper ID for papers).")
+    ],
+    item_type: Annotated[
+        CollectionItemType,
+        typer.Argument(help="The type of item (model, dataset, space, paper, collection, or bucket)."),
+    ],
+    note: Annotated[
+        str | None,
+        typer.Option(help="A note to attach to the item (max 500 characters)."),
+    ] = None,
+    exists_ok: Annotated[
+        bool,
+        typer.Option(help="Do not raise an error if the item is already in the collection."),
+    ] = False,
+    token: TokenOpt = None,
+) -> None:
+    """Add an item to a collection."""
+    api = get_hf_api(token=token)
+    collection = api.add_collection_item(
+        collection_slug=collection_slug,
+        item_id=item_id,
+        item_type=item_type.value,  # type: ignore[arg-type]
+        note=note,
+        exists_ok=exists_ok,
+    )
+    out.result("Item added to collection", slug=collection_slug, url=collection.url)
+
+
+@collections_cli.command(
+    "update-item",
+    examples=[
+        'hf collections update-item username/my-collection ITEM_OBJECT_ID --note "Updated note"',
+        "hf collections update-item username/my-collection ITEM_OBJECT_ID --position 0",
+    ],
+)
+def collections_update_item(
+    collection_slug: Annotated[str, typer.Argument(help="The collection slug (e.g., 'username/collection-slug').")],
+    item_object_id: Annotated[
+        str,
+        typer.Argument(help="The ID of the item in the collection (from 'item_object_id' field, not the repo_id)."),
+    ],
+    note: Annotated[
+        str | None,
+        typer.Option(help="A new note for the item (max 500 characters)."),
+    ] = None,
+    position: Annotated[
+        int | None,
+        typer.Option(help="The new position of the item in the collection."),
+    ] = None,
+    token: TokenOpt = None,
+) -> None:
+    """Update an item in a collection."""
+    api = get_hf_api(token=token)
+    api.update_collection_item(
+        collection_slug=collection_slug,
+        item_object_id=item_object_id,
+        note=note,
+        position=position,
+    )
+    out.result("Item updated in collection", slug=collection_slug)
+
+
+@collections_cli.command("delete-item")
+def collections_delete_item(
+    collection_slug: Annotated[str, typer.Argument(help="The collection slug (e.g., 'username/collection-slug').")],
+    item_object_id: Annotated[
+        str,
+        typer.Argument(
+            help="The ID of the item in the collection (retrieved from `item_object_id` field returned by 'hf collections info'."
+        ),
+    ],
+    missing_ok: Annotated[
+        bool,
+        typer.Option(help="Do not raise an error if the item doesn't exist."),
+    ] = False,
+    token: TokenOpt = None,
+) -> None:
+    """Delete an item from a collection."""
+    api = get_hf_api(token=token)
+    api.delete_collection_item(
+        collection_slug=collection_slug,
+        item_object_id=item_object_id,
+        missing_ok=missing_ok,
+    )
+    out.result("Item deleted from collection", slug=collection_slug)

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/cli/datasets.py

@@ -0,0 +1,286 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains commands to interact with datasets on the Hugging Face Hub.
+
+Usage:
+    # list datasets on the Hub
+    hf datasets ls
+
+    # list datasets with a search query
+    hf datasets ls --search "code"
+
+    # get info about a dataset
+    hf datasets info HuggingFaceFW/fineweb
+"""
+
+import enum
+from typing import Annotated, get_args
+
+import typer
+
+from huggingface_hub._dataset_viewer import execute_raw_sql_query
+from huggingface_hub.errors import CLIError, RepositoryNotFoundError, RevisionNotFoundError
+from huggingface_hub.hf_api import DatasetSort_T, ExpandDatasetProperty_T
+from huggingface_hub.repocard import DatasetCard
+
+from ._cli_utils import (
+    REPO_LIST_DEFAULT_LIMIT,
+    AuthorOpt,
+    FilterOpt,
+    LimitOpt,
+    RevisionOpt,
+    SearchOpt,
+    TokenOpt,
+    api_object_to_dict,
+    get_hf_api,
+    make_expand_properties_parser,
+    typer_factory,
+)
+from ._file_listing import list_repo_files_cmd
+from ._output import out
+
+
+_EXPAND_PROPERTIES = sorted(get_args(ExpandDatasetProperty_T))
+_SORT_OPTIONS = get_args(DatasetSort_T)
+DatasetSortEnum = enum.Enum("DatasetSortEnum", {s: s for s in _SORT_OPTIONS}, type=str)  # type: ignore[misc]
+
+
+ExpandOpt = Annotated[
+    str | None,
+    typer.Option(
+        help=f"Comma-separated properties to return. When used, only the listed properties (and id) are returned. Example: '--expand=downloads,likes,tags'. Valid: {', '.join(_EXPAND_PROPERTIES)}.",
+        callback=make_expand_properties_parser(_EXPAND_PROPERTIES),
+    ),
+]
+
+
+datasets_cli = typer_factory(help="Interact with datasets on the Hub.")
+
+
+@datasets_cli.command(
+    "list | ls",
+    examples=[
+        "hf datasets ls",
+        "hf datasets ls --sort downloads --limit 10",
+        'hf datasets ls --search "code"',
+        "hf datasets ls --filter benchmark:official",
+        "hf datasets ls HuggingFaceFW/fineweb",
+        "hf datasets ls HuggingFaceFW/fineweb -R",
+        "hf datasets ls HuggingFaceFW/fineweb --tree -h",
+    ],
+)
+def datasets_ls(
+    repo_id: Annotated[
+        str | None,
+        typer.Argument(help="Dataset ID (e.g. `username/repo-name`) to list files from. If omitted, lists datasets."),
+    ] = None,
+    search: SearchOpt = None,
+    author: AuthorOpt = None,
+    filter: FilterOpt = None,
+    sort: Annotated[
+        DatasetSortEnum | None,
+        typer.Option(help="Sort results."),
+    ] = None,
+    limit: LimitOpt = REPO_LIST_DEFAULT_LIMIT,
+    expand: ExpandOpt = None,
+    human_readable: Annotated[
+        bool,
+        typer.Option("--human-readable", "-h", help="Show sizes in human readable format (only for listing files)."),
+    ] = False,
+    as_tree: Annotated[
+        bool,
+        typer.Option("--tree", help="List files in tree format (only for listing files)."),
+    ] = False,
+    recursive: Annotated[
+        bool,
+        typer.Option("--recursive", "-R", help="List files recursively (only for listing files)."),
+    ] = False,
+    revision: RevisionOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """List datasets on the Hub, or files in a dataset repo.
+
+    When called with no argument, lists datasets on the Hub.
+    When called with a dataset ID, lists files in that dataset repo.
+    """
+    if repo_id is not None:
+        if search is not None:
+            raise typer.BadParameter("Cannot use --search when listing files.")
+        if author is not None:
+            raise typer.BadParameter("Cannot use --author when listing files.")
+        if filter is not None:
+            raise typer.BadParameter("Cannot use --filter when listing files.")
+        if sort is not None:
+            raise typer.BadParameter("Cannot use --sort when listing files.")
+        if limit != REPO_LIST_DEFAULT_LIMIT:
+            raise typer.BadParameter("Cannot use --limit when listing files.")
+        if expand is not None:
+            raise typer.BadParameter("Cannot use --expand when listing files.")
+        return list_repo_files_cmd(
+            repo_id=repo_id,
+            repo_type="dataset",
+            human_readable=human_readable,
+            as_tree=as_tree,
+            recursive=recursive,
+            revision=revision,
+            token=token,
+        )
+
+    if as_tree:
+        raise typer.BadParameter("Cannot use --tree when listing datasets.")
+    if recursive:
+        raise typer.BadParameter("Cannot use --recursive when listing datasets.")
+    if human_readable:
+        raise typer.BadParameter("Cannot use --human-readable when listing datasets.")
+    if revision is not None:
+        raise typer.BadParameter("Cannot use --revision when listing datasets.")
+
+    api = get_hf_api(token=token)
+    sort_key = sort.value if sort else None
+    results = [
+        api_object_to_dict(dataset_info)
+        for dataset_info in api.list_datasets(
+            filter=filter,
+            author=author,
+            search=search,
+            sort=sort_key,
+            limit=limit,
+            expand=expand,  # type: ignore
+        )
+    ]
+    out.table(results)
+
+
+@datasets_cli.command(
+    "leaderboard",
+    examples=[
+        "hf datasets leaderboard SWE-bench/SWE-bench_Verified",
+        "hf datasets leaderboard SWE-bench/SWE-bench_Verified --limit 5 --format json",
+        "hf datasets ls --filter benchmark:official  # list available leaderboards",
+    ],
+)
+def datasets_leaderboard(
+    dataset_id: Annotated[str, typer.Argument(help="The benchmark dataset ID (e.g. `SWE-bench/SWE-bench_Verified`).")],
+    limit: LimitOpt = 20,
+    token: TokenOpt = None,
+) -> None:
+    """List model scores from a dataset leaderboard. This command helps find the best models for a task or compare models by benchmark scores. Use 'hf datasets ls --filter benchmark:official' to list available leaderboards."""
+    api = get_hf_api(token=token)
+    leaderboard = api.get_dataset_leaderboard(repo_id=dataset_id)
+    results = [api_object_to_dict(entry) for entry in leaderboard[:limit]]
+    out.table(
+        results,
+        headers=["rank", "model_id", "value", "source"],
+        id_key="model_id",
+        alignments={"rank": "right", "value": "right"},
+    )
+    out.hint("Use 'hf datasets ls --filter benchmark:official' to list available leaderboards.")
+    if leaderboard:
+        out.hint(f"Use 'hf models info {leaderboard[0].model_id}' to get details about a model.")
+
+
+@datasets_cli.command(
+    "info",
+    examples=[
+        "hf datasets info HuggingFaceFW/fineweb",
+        "hf datasets info my-dataset --expand downloads,likes,tags",
+    ],
+)
+def datasets_info(
+    dataset_id: Annotated[str, typer.Argument(help="The dataset ID (e.g. `username/repo-name`).")],
+    revision: RevisionOpt = None,
+    expand: ExpandOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Get info about a dataset on the Hub."""
+    api = get_hf_api(token=token)
+    try:
+        info = api.dataset_info(repo_id=dataset_id, revision=revision, expand=expand)  # type: ignore
+    except RepositoryNotFoundError as e:
+        raise CLIError(f"Dataset '{dataset_id}' not found.") from e
+    except RevisionNotFoundError as e:
+        raise CLIError(f"Revision '{revision}' not found on '{dataset_id}'.") from e
+    out.dict(info)
+
+
+@datasets_cli.command(
+    "parquet",
+    examples=[
+        "hf datasets parquet cfahlgren1/hub-stats",
+        "hf datasets parquet cfahlgren1/hub-stats --subset models",
+        "hf datasets parquet cfahlgren1/hub-stats --split train",
+        "hf datasets parquet cfahlgren1/hub-stats --format json",
+    ],
+)
+def datasets_parquet(
+    dataset_id: Annotated[str, typer.Argument(help="The dataset ID (e.g. `username/repo-name`).")],
+    subset: Annotated[str | None, typer.Option("--subset", help="Filter parquet entries by subset/config.")] = None,
+    split: Annotated[str | None, typer.Option(help="Filter parquet entries by split.")] = None,
+    token: TokenOpt = None,
+) -> None:
+    """List parquet file URLs available for a dataset."""
+    api = get_hf_api(token=token)
+    entries = api.list_dataset_parquet_files(repo_id=dataset_id, config=subset)
+    filtered = [entry for entry in entries if split is None or entry.split == split]
+    results = [
+        {"subset": entry.config, "split": entry.split, "url": entry.url, "size": entry.size} for entry in filtered
+    ]
+    out.table(results, headers=["subset", "split", "url", "size"], id_key="url")
+
+
+@datasets_cli.command(
+    "sql",
+    examples=[
+        "hf datasets sql \"SELECT COUNT(*) AS rows FROM read_parquet('https://huggingface.co/api/datasets/cfahlgren1/hub-stats/parquet/models/train/0.parquet')\"",
+        "hf datasets sql \"SELECT * FROM read_parquet('https://huggingface.co/api/datasets/cfahlgren1/hub-stats/parquet/models/train/0.parquet') LIMIT 5\" --format json",
+    ],
+)
+def datasets_sql(
+    sql: Annotated[str, typer.Argument(help="Raw SQL query to execute.")],
+    token: TokenOpt = None,
+) -> None:
+    """Execute a raw SQL query with DuckDB against dataset parquet URLs."""
+    try:
+        result = execute_raw_sql_query(sql_query=sql, token=token)
+    except ImportError as e:
+        raise CLIError(str(e)) from e
+    out.table(result)
+
+
+@datasets_cli.command(
+    "card",
+    examples=[
+        "hf datasets card HuggingFaceFW/fineweb",
+        "hf datasets card HuggingFaceFW/fineweb --metadata",
+        "hf datasets card HuggingFaceFW/fineweb --metadata --format json",
+        "hf datasets card HuggingFaceFW/fineweb --text",
+    ],
+)
+def datasets_card(
+    dataset_id: Annotated[str, typer.Argument(help="The dataset ID (e.g. `username/repo-name`).")],
+    metadata: Annotated[bool, typer.Option("--metadata", help="Output only the metadata from the card.")] = False,
+    text: Annotated[bool, typer.Option("--text", help="Output only the text body (no metadata).")] = False,
+    token: TokenOpt = None,
+) -> None:
+    """Get the dataset card (README) for a dataset on the Hub."""
+    if metadata and text:
+        raise CLIError("--metadata and --text are mutually exclusive.")
+    card = DatasetCard.load(dataset_id, token=token)
+    if metadata:
+        out.dict(card.data.to_dict())
+    elif text:
+        out.text(card.text)
+    else:
+        out.text(card.content)
+        out.hint(f"Use `hf datasets card {dataset_id} --metadata` to extract only the card metadata.")

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/cli/deprecated_cli.py

@@ -0,0 +1,35 @@
+"""Deprecated `huggingface-cli` entry point. Warns and exits."""
+
+import shutil
+import sys
+
+from ._output import out
+
+
+def main() -> None:
+    out.warning("`huggingface-cli` is deprecated and no longer works. Use `hf` instead.\n")
+
+    if shutil.which("hf"):
+        from huggingface_hub.cli._cli_utils import check_cli_update
+
+        check_cli_update("huggingface_hub")
+        out.hint("`hf` is already installed! Use it directly.\n")
+    else:
+        out.hint(
+            "Install `hf`:\n"
+            "  Standalone (recommended): curl -LsSf https://hf.co/cli/install.sh | bash\n"
+            "  Using Homebrew:           brew install hf\n"
+            "  Using pip:                pip install huggingface_hub\n",
+        )
+
+    out.hint(
+        "Examples:\n"
+        "  hf auth login\n"
+        "  hf download unsloth/gemma-4-31B-it-GGUF\n"
+        "  hf upload my-cool-model . .\n"
+        '  hf models ls --search "gemma"\n'
+        "  hf repos ls --format json\n"
+        "  hf jobs run python:3.12 python -c 'print(\"Hello!\")'\n"
+        "  hf --help\n",
+    )
+    sys.exit(1)

micromamba_root/envs/pytorch_env/Lib/site-packages/huggingface_hub/cli/discussions.py

@@ -0,0 +1,450 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains commands to interact with discussions and pull requests on the Hugging Face Hub."""
+
+import enum
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from huggingface_hub import constants
+
+from ._cli_utils import (
+    AuthorOpt,
+    LimitOpt,
+    RepoIdArg,
+    RepoType,
+    RepoTypeOpt,
+    TokenOpt,
+    api_object_to_dict,
+    get_hf_api,
+    typer_factory,
+)
+from ._output import out
+
+
+class DiscussionStatus(str, enum.Enum):
+    open = "open"
+    closed = "closed"
+    merged = "merged"
+    draft = "draft"
+    all = "all"
+
+
+class DiscussionKind(str, enum.Enum):
+    all = "all"
+    discussion = "discussion"
+    pull_request = "pull_request"
+
+
+# "merged" and "draft" are valid Discussion statuses but the Hub API filter
+# (DiscussionStatusFilter) only accepts "all", "open", "closed". When the user
+# asks for merged/draft we fetch with api_status=None (i.e. all) and filter
+# client-side.
+_CLIENT_SIDE_STATUSES = {"merged", "draft"}
+
+
+DiscussionNumArg = Annotated[
+    int,
+    typer.Argument(
+        help="The discussion or pull request number.",
+        min=1,
+    ),
+]
+
+
+def _read_body(body: str | None, body_file: Path | None) -> str | None:
+    """Resolve body text from --body or --body-file (supports '-' for stdin)."""
+    if body is not None and body_file is not None:
+        raise typer.BadParameter("Cannot use both --body and --body-file.")
+    if body_file is not None:
+        if str(body_file) == "-":
+            return sys.stdin.read()
+        return body_file.read_text(encoding="utf-8")
+    return body
+
+
+discussions_cli = typer_factory(help="Manage discussions and pull requests on the Hub.")
+
+
+@discussions_cli.command(
+    "list | ls",
+    examples=[
+        "hf discussions list username/my-model",
+        "hf discussions list username/my-model --kind pull_request --status merged",
+        "hf discussions list username/my-dataset --type dataset --status closed",
+        "hf discussions list username/my-model --author alice --format json",
+    ],
+)
+def discussion_list(
+    repo_id: RepoIdArg,
+    status: Annotated[
+        DiscussionStatus,
+        typer.Option(
+            "-s",
+            "--status",
+            help="Filter by status (open, closed, merged, draft, all).",
+        ),
+    ] = DiscussionStatus.open,
+    kind: Annotated[
+        DiscussionKind,
+        typer.Option(
+            "-k",
+            "--kind",
+            help="Filter by kind (discussion, pull_request, all).",
+        ),
+    ] = DiscussionKind.all,
+    author: AuthorOpt = None,
+    limit: LimitOpt = 30,
+    repo_type: RepoTypeOpt = RepoType.model,
+    token: TokenOpt = None,
+) -> None:
+    """List discussions and pull requests on a repo."""
+    api = get_hf_api(token=token)
+
+    api_status: constants.DiscussionStatusFilter | None
+    if status == DiscussionStatus.open:
+        api_status = "open"
+    elif status == DiscussionStatus.closed:
+        api_status = "closed"
+    else:
+        api_status = None
+
+    api_discussion_type: constants.DiscussionTypeFilter | None
+    if kind == DiscussionKind.all:
+        api_discussion_type = None
+    else:
+        api_discussion_type = kind.value  # type: ignore[assignment]
+
+    discussions = []
+    for d in api.get_repo_discussions(
+        repo_id=repo_id,
+        author=author,
+        discussion_type=api_discussion_type,
+        discussion_status=api_status,
+        repo_type=repo_type.value,
+    ):
+        if status.value in _CLIENT_SIDE_STATUSES and d.status != status.value:
+            continue
+        discussions.append(d)
+        if len(discussions) >= limit:
+            break
+
+    items = [api_object_to_dict(d) for d in discussions]
+    out.table(
+        items,
+        headers=["num", "title", "is_pull_request", "status", "author", "created_at"],
+        id_key="num",
+        alignments={"num": "right"},
+    )
+
+
+@discussions_cli.command(
+    "info",
+    examples=[
+        "hf discussions info username/my-model 5",
+        "hf discussions info username/my-model 5 --format json",
+    ],
+)
+def discussion_info(
+    repo_id: RepoIdArg,
+    num: DiscussionNumArg,
+    repo_type: RepoTypeOpt = RepoType.model,
+    token: TokenOpt = None,
+) -> None:
+    """Get info about a discussion or pull request."""
+    api = get_hf_api(token=token)
+    details = api.get_discussion_details(
+        repo_id=repo_id,
+        discussion_num=num,
+        repo_type=repo_type.value,
+    )
+    out.dict(details)
+
+
+@discussions_cli.command(
+    "create",
+    examples=[
+        'hf discussions create username/my-model --title "Bug report"',
+        'hf discussions create username/my-model --title "Feature request" --body "Please add X"',
+        'hf discussions create username/my-model --title "Fix typo" --pull-request',
+        'hf discussions create username/my-dataset --type dataset --title "Data quality issue"',
+    ],
+)
+def discussion_create(
+    repo_id: RepoIdArg,
+    title: Annotated[
+        str,
+        typer.Option(
+            "--title",
+            help="The title of the discussion or pull request.",
+        ),
+    ],
+    body: Annotated[
+        str | None,
+        typer.Option(
+            "--body",
+            help="The description (supports Markdown).",
+        ),
+    ] = None,
+    body_file: Annotated[
+        Path | None,
+        typer.Option(
+            "--body-file",
+            help="Read the description from a file. Use '-' for stdin.",
+        ),
+    ] = None,
+    pull_request: Annotated[
+        bool,
+        typer.Option(
+            "--pull-request",
+            "--pr",
+            help="Create a pull request instead of a discussion.",
+        ),
+    ] = False,
+    repo_type: RepoTypeOpt = RepoType.model,
+    token: TokenOpt = None,
+) -> None:
+    """Create a new discussion or pull request on a repo."""
+    description = _read_body(body, body_file)
+    api = get_hf_api(token=token)
+    discussion = api.create_discussion(
+        repo_id=repo_id,
+        title=title,
+        description=description,
+        repo_type=repo_type.value,
+        pull_request=pull_request,
+    )
+    kind = "pull request" if pull_request else "discussion"
+    ref = f"refs/pr/{discussion.num}" if pull_request else None
+    out.result(f"Created {kind} #{discussion.num} on {repo_id}", num=discussion.num, url=discussion.url, ref=ref)
+
+
+@discussions_cli.command(
+    "comment",
+    examples=[
+        'hf discussions comment username/my-model 5 --body "Thanks for reporting!"',
+        'hf discussions comment username/my-model 5 --body "LGTM!"',
+    ],
+)
+def discussion_comment(
+    repo_id: RepoIdArg,
+    num: DiscussionNumArg,
+    body: Annotated[
+        str | None,
+        typer.Option(
+            "--body",
+            help="The comment text (supports Markdown).",
+        ),
+    ] = None,
+    body_file: Annotated[
+        Path | None,
+        typer.Option(
+            "--body-file",
+            help="Read the comment from a file. Use '-' for stdin.",
+        ),
+    ] = None,
+    repo_type: RepoTypeOpt = RepoType.model,
+    token: TokenOpt = None,
+) -> None:
+    """Comment on a discussion or pull request."""
+    comment = _read_body(body, body_file)
+    if comment is None:
+        raise typer.BadParameter("Either --body or --body-file is required.")
+    api = get_hf_api(token=token)
+    api.comment_discussion(
+        repo_id=repo_id,
+        discussion_num=num,
+        comment=comment,
+        repo_type=repo_type.value,
+    )
+    out.result(f"Commented on #{num} in {repo_id}", num=num, repo=repo_id)
+
+
+@discussions_cli.command(
+    "close",
+    examples=[
+        "hf discussions close username/my-model 5",
+        'hf discussions close username/my-model 5 --comment "Closing as resolved."',
+    ],
+)
+def discussion_close(
+    repo_id: RepoIdArg,
+    num: DiscussionNumArg,
+    comment: Annotated[
+        str | None,
+        typer.Option(
+            "--comment",
+            help="An optional comment to post when closing.",
+        ),
+    ] = None,
+    yes: Annotated[
+        bool,
+        typer.Option(
+            "--yes",
+            "-y",
+            help="Skip confirmation prompt.",
+        ),
+    ] = False,
+    repo_type: RepoTypeOpt = RepoType.model,
+    token: TokenOpt = None,
+) -> None:
+    """Close a discussion or pull request."""
+    out.confirm(f"Close #{num} on '{repo_id}'?", yes=yes)
+    api = get_hf_api(token=token)
+    api.change_discussion_status(
+        repo_id=repo_id,
+        discussion_num=num,
+        new_status="closed",
+        comment=comment,
+        repo_type=repo_type.value,
+    )
+    out.result(f"Closed #{num} in {repo_id}", num=num, repo=repo_id)
+
+
+@discussions_cli.command(
+    "reopen",
+    examples=[
+        "hf discussions reopen username/my-model 5",
+        'hf discussions reopen username/my-model 5 --comment "Reopening for further investigation."',
+    ],
+)
+def discussion_reopen(
+    repo_id: RepoIdArg,
+    num: DiscussionNumArg,
+    comment: Annotated[
+        str | None,
+        typer.Option(
+            "--comment",
+            help="An optional comment to post when reopening.",
+        ),
+    ] = None,
+    yes: Annotated[
+        bool,
+        typer.Option(
+            "--yes",
+            "-y",
+            help="Skip confirmation prompt.",
+        ),
+    ] = False,
+    repo_type: RepoTypeOpt = RepoType.model,
+    token: TokenOpt = None,
+) -> None:
+    """Reopen a closed discussion or pull request."""
+    out.confirm(f"Reopen #{num} on '{repo_id}'?", yes=yes)
+    api = get_hf_api(token=token)
+    api.change_discussion_status(
+        repo_id=repo_id,
+        discussion_num=num,
+        new_status="open",
+        comment=comment,
+        repo_type=repo_type.value,
+    )
+    out.result(f"Reopened #{num} in {repo_id}", num=num, repo=repo_id)
+
+
+@discussions_cli.command(
+    "rename",
+    examples=[
+        'hf discussions rename username/my-model 5 "Updated title"',
+    ],
+)
+def discussion_rename(
+    repo_id: RepoIdArg,
+    num: DiscussionNumArg,
+    new_title: Annotated[
+        str,
+        typer.Argument(
+            help="The new title.",
+        ),
+    ],
+    repo_type: RepoTypeOpt = RepoType.model,
+    token: TokenOpt = None,
+) -> None:
+    """Rename a discussion or pull request."""
+    api = get_hf_api(token=token)
+    api.rename_discussion(
+        repo_id=repo_id,
+        discussion_num=num,
+        new_title=new_title,
+        repo_type=repo_type.value,
+    )
+    out.result(f"Renamed #{num} in {repo_id}", num=num, repo=repo_id, title=new_title)
+
+
+@discussions_cli.command(
+    "merge",
+    examples=[
+        "hf discussions merge username/my-model 5",
+        'hf discussions merge username/my-model 5 --comment "Merging, thanks!"',
+    ],
+)
+def discussion_merge(
+    repo_id: RepoIdArg,
+    num: DiscussionNumArg,
+    comment: Annotated[
+        str | None,
+        typer.Option(
+            "--comment",
+            help="An optional comment to post when merging.",
+        ),
+    ] = None,
+    yes: Annotated[
+        bool,
+        typer.Option(
+            "--yes",
+            "-y",
+            help="Skip confirmation prompt.",
+        ),
+    ] = False,
+    repo_type: RepoTypeOpt = RepoType.model,
+    token: TokenOpt = None,
+) -> None:
+    """Merge a pull request."""
+    out.confirm(f"Merge #{num} on '{repo_id}'?", yes=yes)
+    api = get_hf_api(token=token)
+    api.merge_pull_request(
+        repo_id=repo_id,
+        discussion_num=num,
+        comment=comment,
+        repo_type=repo_type.value,
+    )
+    out.result(f"Merged #{num} in {repo_id}", num=num, repo=repo_id)
+
+
+@discussions_cli.command(
+    "diff",
+    examples=[
+        "hf discussions diff username/my-model 5",
+    ],
+)
+def discussion_diff(
+    repo_id: RepoIdArg,
+    num: DiscussionNumArg,
+    repo_type: RepoTypeOpt = RepoType.model,
+    token: TokenOpt = None,
+) -> None:
+    """Show the diff of a pull request."""
+    api = get_hf_api(token=token)
+    details = api.get_discussion_details(
+        repo_id=repo_id,
+        discussion_num=num,
+        repo_type=repo_type.value,
+    )
+    if details.diff:
+        out.text(details.diff)
+    else:
+        out.text("No diff available.")