Add files using upload-large-folder tool

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub-1.23.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.

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/__init__.py

@@ -0,0 +1,1804 @@
+# 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.
+
+# ***********
+# `huggingface_hub` init has 2 modes:
+# - Normal usage:
+#       If imported to use it, all modules and functions are lazy-loaded. This means
+#       they exist at top level in module but are imported only the first time they are
+#       used. This way, `from huggingface_hub import something` will import `something`
+#       quickly without the hassle of importing all the features from `huggingface_hub`.
+# - Static check:
+#       If statically analyzed, all modules and functions are loaded normally. This way
+#       static typing check works properly as well as autocomplete in text editors and
+#       IDEs.
+#
+# The static model imports are done inside the `if TYPE_CHECKING:` statement at
+# the bottom of this file. Since module/functions imports are duplicated, it is
+# mandatory to make sure to add them twice when adding one. This is checked in the
+# `make quality` command.
+#
+# To update the static imports, please run the following command and commit the changes.
+# ```
+# # Use script
+# python utils/check_static_imports.py --update-file
+#
+# # Or run style on codebase
+# make style
+# ```
+#
+# ***********
+# Lazy loader vendored from https://github.com/scientific-python/lazy_loader
+import importlib
+import os
+import sys
+from typing import TYPE_CHECKING
+
+
+__version__ = "1.23.0"
+
+# Alphabetical order of definitions is ensured in tests
+# WARNING: any comment added in this dictionary definition will be lost when
+# re-generating the file !
+_SUBMOD_ATTRS = {
+    "_buckets": [
+        "BucketFile",
+        "BucketFileMetadata",
+        "BucketFolder",
+        "BucketInfo",
+        "BucketUrl",
+        "SyncOperation",
+        "SyncPlan",
+    ],
+    "_commit_scheduler": [
+        "CommitScheduler",
+    ],
+    "_eval_results": [
+        "EvalResultEntry",
+        "eval_result_entries_to_yaml",
+        "parse_eval_result_entries",
+    ],
+    "_inference_endpoints": [
+        "InferenceEndpoint",
+        "InferenceEndpointError",
+        "InferenceEndpointStatus",
+        "InferenceEndpointTimeoutError",
+        "InferenceEndpointType",
+    ],
+    "_jobs_api": [
+        "JobAccelerator",
+        "JobDurations",
+        "JobHardware",
+        "JobHardwareInfo",
+        "JobInfo",
+        "JobInitiator",
+        "JobOwner",
+        "JobStage",
+        "JobStatus",
+    ],
+    "_login": [
+        "auth_list",
+        "auth_switch",
+        "interpreter_login",
+        "login",
+        "logout",
+        "notebook_login",
+    ],
+    "_oauth": [
+        "OAuthInfo",
+        "OAuthOrgInfo",
+        "OAuthUserInfo",
+        "attach_huggingface_oauth",
+        "parse_huggingface_oauth",
+    ],
+    "_sandbox": [
+        "Sandbox",
+        "SandboxCommandResult",
+        "SandboxPool",
+        "SandboxProcess",
+    ],
+    "_snapshot_download": [
+        "get_cached_repo_tree",
+        "snapshot_download",
+    ],
+    "_space_api": [
+        "SpaceHardware",
+        "SpaceRuntime",
+        "SpaceSecret",
+        "SpaceStage",
+        "SpaceStorage",
+        "SpaceVariable",
+        "Volume",
+    ],
+    "_tensorboard_logger": [
+        "HFSummaryWriter",
+    ],
+    "_webhooks_payload": [
+        "WebhookPayload",
+        "WebhookPayloadComment",
+        "WebhookPayloadDiscussion",
+        "WebhookPayloadDiscussionChanges",
+        "WebhookPayloadEvent",
+        "WebhookPayloadMovedTo",
+        "WebhookPayloadRepo",
+        "WebhookPayloadUrl",
+        "WebhookPayloadWebhook",
+    ],
+    "_webhooks_server": [
+        "WebhooksServer",
+        "webhook_endpoint",
+    ],
+    "cli._cli_utils": [
+        "check_cli_update",
+        "typer_factory",
+    ],
+    "community": [
+        "Discussion",
+        "DiscussionComment",
+        "DiscussionCommit",
+        "DiscussionEvent",
+        "DiscussionStatusChange",
+        "DiscussionTitleChange",
+        "DiscussionWithDetails",
+    ],
+    "constants": [
+        "CONFIG_NAME",
+        "FLAX_WEIGHTS_NAME",
+        "HUGGINGFACE_CO_URL_HOME",
+        "HUGGINGFACE_CO_URL_TEMPLATE",
+        "PYTORCH_WEIGHTS_NAME",
+        "REPO_TYPE_DATASET",
+        "REPO_TYPE_MODEL",
+        "REPO_TYPE_SPACE",
+        "TF2_WEIGHTS_NAME",
+        "TF_WEIGHTS_NAME",
+        "is_offline_mode",
+    ],
+    "fastai_utils": [
+        "_save_pretrained_fastai",
+        "from_pretrained_fastai",
+        "push_to_hub_fastai",
+    ],
+    "file_download": [
+        "DryRunFileInfo",
+        "HfFileMetadata",
+        "_CACHED_NO_EXIST",
+        "get_hf_file_metadata",
+        "hf_hub_download",
+        "hf_hub_url",
+        "try_to_load_from_cache",
+    ],
+    "hf_api": [
+        "Collection",
+        "CollectionItem",
+        "CommitInfo",
+        "CommitOperation",
+        "CommitOperationAdd",
+        "CommitOperationCopy",
+        "CommitOperationDelete",
+        "DatasetInfo",
+        "DatasetLeaderboardEntry",
+        "GitCommitInfo",
+        "GitRefInfo",
+        "GitRefs",
+        "HfApi",
+        "KernelInfo",
+        "ModelInfo",
+        "Organization",
+        "RepoFile",
+        "RepoFolder",
+        "RepoStorageInfo",
+        "RepoUrl",
+        "SpaceInfo",
+        "SpaceSearchResult",
+        "SpaceTemplate",
+        "User",
+        "UserLikes",
+        "WebhookInfo",
+        "WebhookWatchedItem",
+        "accept_access_request",
+        "add_collection_item",
+        "add_space_secret",
+        "add_space_variable",
+        "auth_check",
+        "batch_bucket_files",
+        "bucket_info",
+        "cancel_access_request",
+        "cancel_job",
+        "change_discussion_status",
+        "comment_discussion",
+        "copy_files",
+        "create_branch",
+        "create_bucket",
+        "create_collection",
+        "create_commit",
+        "create_discussion",
+        "create_inference_endpoint",
+        "create_inference_endpoint_from_catalog",
+        "create_pull_request",
+        "create_repo",
+        "create_scheduled_job",
+        "create_scheduled_uv_job",
+        "create_tag",
+        "create_webhook",
+        "dataset_info",
+        "delete_branch",
+        "delete_bucket",
+        "delete_collection",
+        "delete_collection_item",
+        "delete_file",
+        "delete_folder",
+        "delete_inference_endpoint",
+        "delete_repo",
+        "delete_scheduled_job",
+        "delete_space_secret",
+        "delete_space_storage",
+        "delete_space_variable",
+        "delete_space_volumes",
+        "delete_tag",
+        "delete_webhook",
+        "disable_space_dev_mode",
+        "disable_webhook",
+        "download_bucket_files",
+        "duplicate_repo",
+        "duplicate_space",
+        "edit_discussion_comment",
+        "enable_space_dev_mode",
+        "enable_webhook",
+        "fetch_job_logs",
+        "fetch_job_metrics",
+        "fetch_space_logs",
+        "file_exists",
+        "get_bucket_file_metadata",
+        "get_bucket_paths_info",
+        "get_collection",
+        "get_dataset_leaderboard",
+        "get_dataset_tags",
+        "get_discussion_details",
+        "get_full_repo_name",
+        "get_inference_endpoint",
+        "get_local_safetensors_metadata",
+        "get_model_tags",
+        "get_organization_overview",
+        "get_paths_info",
+        "get_repo_discussions",
+        "get_safetensors_metadata",
+        "get_space_runtime",
+        "get_space_secrets",
+        "get_space_variables",
+        "get_user_overview",
+        "get_webhook",
+        "grant_access",
+        "inspect_job",
+        "inspect_scheduled_job",
+        "kernel_info",
+        "list_accepted_access_requests",
+        "list_bucket_tree",
+        "list_buckets",
+        "list_collections",
+        "list_daily_papers",
+        "list_dataset_parquet_files",
+        "list_datasets",
+        "list_inference_catalog",
+        "list_inference_endpoints",
+        "list_jobs",
+        "list_jobs_hardware",
+        "list_lfs_files",
+        "list_liked_repos",
+        "list_models",
+        "list_organization_followers",
+        "list_organization_members",
+        "list_papers",
+        "list_pending_access_requests",
+        "list_rejected_access_requests",
+        "list_repo_commits",
+        "list_repo_files",
+        "list_repo_likers",
+        "list_repo_refs",
+        "list_repo_tree",
+        "list_space_templates",
+        "list_spaces",
+        "list_spaces_hardware",
+        "list_user_followers",
+        "list_user_following",
+        "list_user_repos",
+        "list_webhooks",
+        "merge_pull_request",
+        "model_info",
+        "move_bucket",
+        "move_repo",
+        "paper_info",
+        "parse_local_safetensors_file_metadata",
+        "parse_safetensors_file_metadata",
+        "pause_inference_endpoint",
+        "pause_space",
+        "permanently_delete_lfs_files",
+        "preupload_lfs_files",
+        "read_paper",
+        "reject_access_request",
+        "rename_discussion",
+        "repo_exists",
+        "repo_info",
+        "repo_type_and_id_from_hf_id",
+        "request_space_hardware",
+        "request_space_storage",
+        "restart_space",
+        "resume_inference_endpoint",
+        "resume_scheduled_job",
+        "revision_exists",
+        "run_as_future",
+        "run_job",
+        "run_uv_job",
+        "scale_to_zero_inference_endpoint",
+        "search_spaces",
+        "set_space_sleep_time",
+        "set_space_volumes",
+        "space_info",
+        "super_squash_history",
+        "suspend_scheduled_job",
+        "sync_bucket",
+        "sync_job_volume",
+        "trigger_scheduled_job",
+        "unlike",
+        "update_collection_item",
+        "update_collection_metadata",
+        "update_inference_endpoint",
+        "update_job_labels",
+        "update_repo_settings",
+        "update_scheduled_job_labels",
+        "update_webhook",
+        "upload_file",
+        "upload_folder",
+        "upload_large_folder",
+        "verify_repo_checksums",
+        "wait_for_job",
+        "wait_for_space",
+        "whoami",
+    ],
+    "hf_file_system": [
+        "HfFileSystem",
+        "HfFileSystemFile",
+        "HfFileSystemResolvedPath",
+        "HfFileSystemStreamFile",
+        "hffs",
+    ],
+    "hub_mixin": [
+        "ModelHubMixin",
+        "PyTorchModelHubMixin",
+    ],
+    "inference._client": [
+        "InferenceClient",
+        "InferenceTimeoutError",
+    ],
+    "inference._generated._async_client": [
+        "AsyncInferenceClient",
+    ],
+    "inference._generated.types": [
+        "AudioClassificationInput",
+        "AudioClassificationOutputElement",
+        "AudioClassificationOutputTransform",
+        "AudioClassificationParameters",
+        "AudioToAudioInput",
+        "AudioToAudioOutputElement",
+        "AutomaticSpeechRecognitionEarlyStoppingEnum",
+        "AutomaticSpeechRecognitionGenerationParameters",
+        "AutomaticSpeechRecognitionInput",
+        "AutomaticSpeechRecognitionOutput",
+        "AutomaticSpeechRecognitionOutputChunk",
+        "AutomaticSpeechRecognitionParameters",
+        "ChatCompletionInput",
+        "ChatCompletionInputFunctionDefinition",
+        "ChatCompletionInputFunctionName",
+        "ChatCompletionInputGrammarType",
+        "ChatCompletionInputJSONSchema",
+        "ChatCompletionInputMessage",
+        "ChatCompletionInputMessageChunk",
+        "ChatCompletionInputMessageChunkType",
+        "ChatCompletionInputResponseFormatJSONObject",
+        "ChatCompletionInputResponseFormatJSONSchema",
+        "ChatCompletionInputResponseFormatText",
+        "ChatCompletionInputStreamOptions",
+        "ChatCompletionInputTool",
+        "ChatCompletionInputToolCall",
+        "ChatCompletionInputToolChoiceClass",
+        "ChatCompletionInputToolChoiceEnum",
+        "ChatCompletionInputURL",
+        "ChatCompletionOutput",
+        "ChatCompletionOutputComplete",
+        "ChatCompletionOutputFunctionDefinition",
+        "ChatCompletionOutputLogprob",
+        "ChatCompletionOutputLogprobs",
+        "ChatCompletionOutputMessage",
+        "ChatCompletionOutputToolCall",
+        "ChatCompletionOutputTopLogprob",
+        "ChatCompletionOutputUsage",
+        "ChatCompletionStreamOutput",
+        "ChatCompletionStreamOutputChoice",
+        "ChatCompletionStreamOutputDelta",
+        "ChatCompletionStreamOutputDeltaToolCall",
+        "ChatCompletionStreamOutputFunction",
+        "ChatCompletionStreamOutputLogprob",
+        "ChatCompletionStreamOutputLogprobs",
+        "ChatCompletionStreamOutputTopLogprob",
+        "ChatCompletionStreamOutputUsage",
+        "DepthEstimationInput",
+        "DepthEstimationOutput",
+        "DocumentQuestionAnsweringInput",
+        "DocumentQuestionAnsweringInputData",
+        "DocumentQuestionAnsweringOutputElement",
+        "DocumentQuestionAnsweringParameters",
+        "FeatureExtractionInput",
+        "FeatureExtractionInputTruncationDirection",
+        "FillMaskInput",
+        "FillMaskOutputElement",
+        "FillMaskParameters",
+        "ImageClassificationInput",
+        "ImageClassificationOutputElement",
+        "ImageClassificationOutputTransform",
+        "ImageClassificationParameters",
+        "ImageSegmentationInput",
+        "ImageSegmentationOutputElement",
+        "ImageSegmentationParameters",
+        "ImageSegmentationSubtask",
+        "ImageTextToImageInput",
+        "ImageTextToImageOutput",
+        "ImageTextToImageParameters",
+        "ImageTextToImageTargetSize",
+        "ImageTextToVideoInput",
+        "ImageTextToVideoOutput",
+        "ImageTextToVideoParameters",
+        "ImageTextToVideoTargetSize",
+        "ImageToImageInput",
+        "ImageToImageOutput",
+        "ImageToImageParameters",
+        "ImageToImageTargetSize",
+        "ImageToTextEarlyStoppingEnum",
+        "ImageToTextGenerationParameters",
+        "ImageToTextInput",
+        "ImageToTextOutput",
+        "ImageToTextParameters",
+        "ImageToVideoInput",
+        "ImageToVideoOutput",
+        "ImageToVideoParameters",
+        "ImageToVideoTargetSize",
+        "ObjectDetectionBoundingBox",
+        "ObjectDetectionInput",
+        "ObjectDetectionOutputElement",
+        "ObjectDetectionParameters",
+        "Padding",
+        "QuestionAnsweringInput",
+        "QuestionAnsweringInputData",
+        "QuestionAnsweringOutputElement",
+        "QuestionAnsweringParameters",
+        "SentenceSimilarityInput",
+        "SentenceSimilarityInputData",
+        "SummarizationInput",
+        "SummarizationOutput",
+        "SummarizationParameters",
+        "SummarizationTruncationStrategy",
+        "TableQuestionAnsweringInput",
+        "TableQuestionAnsweringInputData",
+        "TableQuestionAnsweringOutputElement",
+        "TableQuestionAnsweringParameters",
+        "Text2TextGenerationInput",
+        "Text2TextGenerationOutput",
+        "Text2TextGenerationParameters",
+        "Text2TextGenerationTruncationStrategy",
+        "TextClassificationInput",
+        "TextClassificationOutputElement",
+        "TextClassificationOutputTransform",
+        "TextClassificationParameters",
+        "TextGenerationInput",
+        "TextGenerationInputGenerateParameters",
+        "TextGenerationInputGrammarType",
+        "TextGenerationOutput",
+        "TextGenerationOutputBestOfSequence",
+        "TextGenerationOutputDetails",
+        "TextGenerationOutputFinishReason",
+        "TextGenerationOutputPrefillToken",
+        "TextGenerationOutputToken",
+        "TextGenerationStreamOutput",
+        "TextGenerationStreamOutputStreamDetails",
+        "TextGenerationStreamOutputToken",
+        "TextToAudioEarlyStoppingEnum",
+        "TextToAudioGenerationParameters",
+        "TextToAudioInput",
+        "TextToAudioOutput",
+        "TextToAudioParameters",
+        "TextToImageInput",
+        "TextToImageOutput",
+        "TextToImageParameters",
+        "TextToSpeechEarlyStoppingEnum",
+        "TextToSpeechGenerationParameters",
+        "TextToSpeechInput",
+        "TextToSpeechOutput",
+        "TextToSpeechParameters",
+        "TextToVideoInput",
+        "TextToVideoOutput",
+        "TextToVideoParameters",
+        "TokenClassificationAggregationStrategy",
+        "TokenClassificationInput",
+        "TokenClassificationOutputElement",
+        "TokenClassificationParameters",
+        "TranslationInput",
+        "TranslationOutput",
+        "TranslationParameters",
+        "TranslationTruncationStrategy",
+        "TypeEnum",
+        "VideoClassificationInput",
+        "VideoClassificationOutputElement",
+        "VideoClassificationOutputTransform",
+        "VideoClassificationParameters",
+        "VisualQuestionAnsweringInput",
+        "VisualQuestionAnsweringInputData",
+        "VisualQuestionAnsweringOutputElement",
+        "VisualQuestionAnsweringParameters",
+        "ZeroShotClassificationInput",
+        "ZeroShotClassificationOutputElement",
+        "ZeroShotClassificationParameters",
+        "ZeroShotImageClassificationInput",
+        "ZeroShotImageClassificationOutputElement",
+        "ZeroShotImageClassificationParameters",
+        "ZeroShotObjectDetectionBoundingBox",
+        "ZeroShotObjectDetectionInput",
+        "ZeroShotObjectDetectionOutputElement",
+        "ZeroShotObjectDetectionParameters",
+    ],
+    "inference._mcp.agent": [
+        "Agent",
+    ],
+    "inference._mcp.mcp_client": [
+        "MCPClient",
+    ],
+    "repocard": [
+        "DatasetCard",
+        "ModelCard",
+        "RepoCard",
+        "SpaceCard",
+        "metadata_eval_result",
+        "metadata_load",
+        "metadata_save",
+        "metadata_update",
+    ],
+    "repocard_data": [
+        "CardData",
+        "DatasetCardData",
+        "EvalResult",
+        "ModelCardData",
+        "SpaceCardData",
+    ],
+    "serialization": [
+        "StateDictSplit",
+        "get_torch_storage_id",
+        "get_torch_storage_size",
+        "load_state_dict_from_file",
+        "load_torch_model",
+        "save_torch_model",
+        "save_torch_state_dict",
+        "split_state_dict_into_shards_factory",
+        "split_torch_state_dict_into_shards",
+    ],
+    "serialization._dduf": [
+        "DDUFEntry",
+        "export_entries_as_dduf",
+        "export_folder_as_dduf",
+        "read_dduf_file",
+    ],
+    "utils": [
+        "ASYNC_CLIENT_FACTORY_T",
+        "CLIENT_FACTORY_T",
+        "CacheNotFound",
+        "CachedFileInfo",
+        "CachedIncompleteFileInfo",
+        "CachedRepoInfo",
+        "CachedRevisionInfo",
+        "CorruptedCacheException",
+        "DeleteCacheStrategy",
+        "HFCacheInfo",
+        "HfUri",
+        "cached_assets_path",
+        "close_session",
+        "dump_environment_info",
+        "get_async_session",
+        "get_session",
+        "get_token",
+        "hf_raise_for_status",
+        "logging",
+        "parse_hf_uri",
+        "scan_cache_dir",
+        "set_async_client_factory",
+        "set_client_factory",
+    ],
+}
+
+# WARNING: __all__ is generated automatically, Any manual edit will be lost when re-generating this file !
+#
+# To update the static imports, please run the following command and commit the changes.
+# ```
+# # Use script
+# python utils/check_all_variable.py --update
+#
+# # Or run style on codebase
+# make style
+# ```
+
+__all__ = [
+    "ASYNC_CLIENT_FACTORY_T",
+    "Agent",
+    "AsyncInferenceClient",
+    "AudioClassificationInput",
+    "AudioClassificationOutputElement",
+    "AudioClassificationOutputTransform",
+    "AudioClassificationParameters",
+    "AudioToAudioInput",
+    "AudioToAudioOutputElement",
+    "AutomaticSpeechRecognitionEarlyStoppingEnum",
+    "AutomaticSpeechRecognitionGenerationParameters",
+    "AutomaticSpeechRecognitionInput",
+    "AutomaticSpeechRecognitionOutput",
+    "AutomaticSpeechRecognitionOutputChunk",
+    "AutomaticSpeechRecognitionParameters",
+    "BucketFile",
+    "BucketFileMetadata",
+    "BucketFolder",
+    "BucketInfo",
+    "BucketUrl",
+    "CLIENT_FACTORY_T",
+    "CONFIG_NAME",
+    "CacheNotFound",
+    "CachedFileInfo",
+    "CachedIncompleteFileInfo",
+    "CachedRepoInfo",
+    "CachedRevisionInfo",
+    "CardData",
+    "ChatCompletionInput",
+    "ChatCompletionInputFunctionDefinition",
+    "ChatCompletionInputFunctionName",
+    "ChatCompletionInputGrammarType",
+    "ChatCompletionInputJSONSchema",
+    "ChatCompletionInputMessage",
+    "ChatCompletionInputMessageChunk",
+    "ChatCompletionInputMessageChunkType",
+    "ChatCompletionInputResponseFormatJSONObject",
+    "ChatCompletionInputResponseFormatJSONSchema",
+    "ChatCompletionInputResponseFormatText",
+    "ChatCompletionInputStreamOptions",
+    "ChatCompletionInputTool",
+    "ChatCompletionInputToolCall",
+    "ChatCompletionInputToolChoiceClass",
+    "ChatCompletionInputToolChoiceEnum",
+    "ChatCompletionInputURL",
+    "ChatCompletionOutput",
+    "ChatCompletionOutputComplete",
+    "ChatCompletionOutputFunctionDefinition",
+    "ChatCompletionOutputLogprob",
+    "ChatCompletionOutputLogprobs",
+    "ChatCompletionOutputMessage",
+    "ChatCompletionOutputToolCall",
+    "ChatCompletionOutputTopLogprob",
+    "ChatCompletionOutputUsage",
+    "ChatCompletionStreamOutput",
+    "ChatCompletionStreamOutputChoice",
+    "ChatCompletionStreamOutputDelta",
+    "ChatCompletionStreamOutputDeltaToolCall",
+    "ChatCompletionStreamOutputFunction",
+    "ChatCompletionStreamOutputLogprob",
+    "ChatCompletionStreamOutputLogprobs",
+    "ChatCompletionStreamOutputTopLogprob",
+    "ChatCompletionStreamOutputUsage",
+    "Collection",
+    "CollectionItem",
+    "CommitInfo",
+    "CommitOperation",
+    "CommitOperationAdd",
+    "CommitOperationCopy",
+    "CommitOperationDelete",
+    "CommitScheduler",
+    "CorruptedCacheException",
+    "DDUFEntry",
+    "DatasetCard",
+    "DatasetCardData",
+    "DatasetInfo",
+    "DatasetLeaderboardEntry",
+    "DeleteCacheStrategy",
+    "DepthEstimationInput",
+    "DepthEstimationOutput",
+    "Discussion",
+    "DiscussionComment",
+    "DiscussionCommit",
+    "DiscussionEvent",
+    "DiscussionStatusChange",
+    "DiscussionTitleChange",
+    "DiscussionWithDetails",
+    "DocumentQuestionAnsweringInput",
+    "DocumentQuestionAnsweringInputData",
+    "DocumentQuestionAnsweringOutputElement",
+    "DocumentQuestionAnsweringParameters",
+    "DryRunFileInfo",
+    "EvalResult",
+    "EvalResultEntry",
+    "FLAX_WEIGHTS_NAME",
+    "FeatureExtractionInput",
+    "FeatureExtractionInputTruncationDirection",
+    "FillMaskInput",
+    "FillMaskOutputElement",
+    "FillMaskParameters",
+    "GitCommitInfo",
+    "GitRefInfo",
+    "GitRefs",
+    "HFCacheInfo",
+    "HFSummaryWriter",
+    "HUGGINGFACE_CO_URL_HOME",
+    "HUGGINGFACE_CO_URL_TEMPLATE",
+    "HfApi",
+    "HfFileMetadata",
+    "HfFileSystem",
+    "HfFileSystemFile",
+    "HfFileSystemResolvedPath",
+    "HfFileSystemStreamFile",
+    "HfUri",
+    "ImageClassificationInput",
+    "ImageClassificationOutputElement",
+    "ImageClassificationOutputTransform",
+    "ImageClassificationParameters",
+    "ImageSegmentationInput",
+    "ImageSegmentationOutputElement",
+    "ImageSegmentationParameters",
+    "ImageSegmentationSubtask",
+    "ImageTextToImageInput",
+    "ImageTextToImageOutput",
+    "ImageTextToImageParameters",
+    "ImageTextToImageTargetSize",
+    "ImageTextToVideoInput",
+    "ImageTextToVideoOutput",
+    "ImageTextToVideoParameters",
+    "ImageTextToVideoTargetSize",
+    "ImageToImageInput",
+    "ImageToImageOutput",
+    "ImageToImageParameters",
+    "ImageToImageTargetSize",
+    "ImageToTextEarlyStoppingEnum",
+    "ImageToTextGenerationParameters",
+    "ImageToTextInput",
+    "ImageToTextOutput",
+    "ImageToTextParameters",
+    "ImageToVideoInput",
+    "ImageToVideoOutput",
+    "ImageToVideoParameters",
+    "ImageToVideoTargetSize",
+    "InferenceClient",
+    "InferenceEndpoint",
+    "InferenceEndpointError",
+    "InferenceEndpointStatus",
+    "InferenceEndpointTimeoutError",
+    "InferenceEndpointType",
+    "InferenceTimeoutError",
+    "JobAccelerator",
+    "JobDurations",
+    "JobHardware",
+    "JobHardwareInfo",
+    "JobInfo",
+    "JobInitiator",
+    "JobOwner",
+    "JobStage",
+    "JobStatus",
+    "KernelInfo",
+    "MCPClient",
+    "ModelCard",
+    "ModelCardData",
+    "ModelHubMixin",
+    "ModelInfo",
+    "OAuthInfo",
+    "OAuthOrgInfo",
+    "OAuthUserInfo",
+    "ObjectDetectionBoundingBox",
+    "ObjectDetectionInput",
+    "ObjectDetectionOutputElement",
+    "ObjectDetectionParameters",
+    "Organization",
+    "PYTORCH_WEIGHTS_NAME",
+    "Padding",
+    "PyTorchModelHubMixin",
+    "QuestionAnsweringInput",
+    "QuestionAnsweringInputData",
+    "QuestionAnsweringOutputElement",
+    "QuestionAnsweringParameters",
+    "REPO_TYPE_DATASET",
+    "REPO_TYPE_MODEL",
+    "REPO_TYPE_SPACE",
+    "RepoCard",
+    "RepoFile",
+    "RepoFolder",
+    "RepoStorageInfo",
+    "RepoUrl",
+    "Sandbox",
+    "SandboxCommandResult",
+    "SandboxPool",
+    "SandboxProcess",
+    "SentenceSimilarityInput",
+    "SentenceSimilarityInputData",
+    "SpaceCard",
+    "SpaceCardData",
+    "SpaceHardware",
+    "SpaceInfo",
+    "SpaceRuntime",
+    "SpaceSearchResult",
+    "SpaceSecret",
+    "SpaceStage",
+    "SpaceStorage",
+    "SpaceTemplate",
+    "SpaceVariable",
+    "StateDictSplit",
+    "SummarizationInput",
+    "SummarizationOutput",
+    "SummarizationParameters",
+    "SummarizationTruncationStrategy",
+    "SyncOperation",
+    "SyncPlan",
+    "TF2_WEIGHTS_NAME",
+    "TF_WEIGHTS_NAME",
+    "TableQuestionAnsweringInput",
+    "TableQuestionAnsweringInputData",
+    "TableQuestionAnsweringOutputElement",
+    "TableQuestionAnsweringParameters",
+    "Text2TextGenerationInput",
+    "Text2TextGenerationOutput",
+    "Text2TextGenerationParameters",
+    "Text2TextGenerationTruncationStrategy",
+    "TextClassificationInput",
+    "TextClassificationOutputElement",
+    "TextClassificationOutputTransform",
+    "TextClassificationParameters",
+    "TextGenerationInput",
+    "TextGenerationInputGenerateParameters",
+    "TextGenerationInputGrammarType",
+    "TextGenerationOutput",
+    "TextGenerationOutputBestOfSequence",
+    "TextGenerationOutputDetails",
+    "TextGenerationOutputFinishReason",
+    "TextGenerationOutputPrefillToken",
+    "TextGenerationOutputToken",
+    "TextGenerationStreamOutput",
+    "TextGenerationStreamOutputStreamDetails",
+    "TextGenerationStreamOutputToken",
+    "TextToAudioEarlyStoppingEnum",
+    "TextToAudioGenerationParameters",
+    "TextToAudioInput",
+    "TextToAudioOutput",
+    "TextToAudioParameters",
+    "TextToImageInput",
+    "TextToImageOutput",
+    "TextToImageParameters",
+    "TextToSpeechEarlyStoppingEnum",
+    "TextToSpeechGenerationParameters",
+    "TextToSpeechInput",
+    "TextToSpeechOutput",
+    "TextToSpeechParameters",
+    "TextToVideoInput",
+    "TextToVideoOutput",
+    "TextToVideoParameters",
+    "TokenClassificationAggregationStrategy",
+    "TokenClassificationInput",
+    "TokenClassificationOutputElement",
+    "TokenClassificationParameters",
+    "TranslationInput",
+    "TranslationOutput",
+    "TranslationParameters",
+    "TranslationTruncationStrategy",
+    "TypeEnum",
+    "User",
+    "UserLikes",
+    "VideoClassificationInput",
+    "VideoClassificationOutputElement",
+    "VideoClassificationOutputTransform",
+    "VideoClassificationParameters",
+    "VisualQuestionAnsweringInput",
+    "VisualQuestionAnsweringInputData",
+    "VisualQuestionAnsweringOutputElement",
+    "VisualQuestionAnsweringParameters",
+    "Volume",
+    "WebhookInfo",
+    "WebhookPayload",
+    "WebhookPayloadComment",
+    "WebhookPayloadDiscussion",
+    "WebhookPayloadDiscussionChanges",
+    "WebhookPayloadEvent",
+    "WebhookPayloadMovedTo",
+    "WebhookPayloadRepo",
+    "WebhookPayloadUrl",
+    "WebhookPayloadWebhook",
+    "WebhookWatchedItem",
+    "WebhooksServer",
+    "ZeroShotClassificationInput",
+    "ZeroShotClassificationOutputElement",
+    "ZeroShotClassificationParameters",
+    "ZeroShotImageClassificationInput",
+    "ZeroShotImageClassificationOutputElement",
+    "ZeroShotImageClassificationParameters",
+    "ZeroShotObjectDetectionBoundingBox",
+    "ZeroShotObjectDetectionInput",
+    "ZeroShotObjectDetectionOutputElement",
+    "ZeroShotObjectDetectionParameters",
+    "_CACHED_NO_EXIST",
+    "_save_pretrained_fastai",
+    "accept_access_request",
+    "add_collection_item",
+    "add_space_secret",
+    "add_space_variable",
+    "attach_huggingface_oauth",
+    "auth_check",
+    "auth_list",
+    "auth_switch",
+    "batch_bucket_files",
+    "bucket_info",
+    "cached_assets_path",
+    "cancel_access_request",
+    "cancel_job",
+    "change_discussion_status",
+    "check_cli_update",
+    "close_session",
+    "comment_discussion",
+    "copy_files",
+    "create_branch",
+    "create_bucket",
+    "create_collection",
+    "create_commit",
+    "create_discussion",
+    "create_inference_endpoint",
+    "create_inference_endpoint_from_catalog",
+    "create_pull_request",
+    "create_repo",
+    "create_scheduled_job",
+    "create_scheduled_uv_job",
+    "create_tag",
+    "create_webhook",
+    "dataset_info",
+    "delete_branch",
+    "delete_bucket",
+    "delete_collection",
+    "delete_collection_item",
+    "delete_file",
+    "delete_folder",
+    "delete_inference_endpoint",
+    "delete_repo",
+    "delete_scheduled_job",
+    "delete_space_secret",
+    "delete_space_storage",
+    "delete_space_variable",
+    "delete_space_volumes",
+    "delete_tag",
+    "delete_webhook",
+    "disable_space_dev_mode",
+    "disable_webhook",
+    "download_bucket_files",
+    "dump_environment_info",
+    "duplicate_repo",
+    "duplicate_space",
+    "edit_discussion_comment",
+    "enable_space_dev_mode",
+    "enable_webhook",
+    "eval_result_entries_to_yaml",
+    "export_entries_as_dduf",
+    "export_folder_as_dduf",
+    "fetch_job_logs",
+    "fetch_job_metrics",
+    "fetch_space_logs",
+    "file_exists",
+    "from_pretrained_fastai",
+    "get_async_session",
+    "get_bucket_file_metadata",
+    "get_bucket_paths_info",
+    "get_cached_repo_tree",
+    "get_collection",
+    "get_dataset_leaderboard",
+    "get_dataset_tags",
+    "get_discussion_details",
+    "get_full_repo_name",
+    "get_hf_file_metadata",
+    "get_inference_endpoint",
+    "get_local_safetensors_metadata",
+    "get_model_tags",
+    "get_organization_overview",
+    "get_paths_info",
+    "get_repo_discussions",
+    "get_safetensors_metadata",
+    "get_session",
+    "get_space_runtime",
+    "get_space_secrets",
+    "get_space_variables",
+    "get_token",
+    "get_torch_storage_id",
+    "get_torch_storage_size",
+    "get_user_overview",
+    "get_webhook",
+    "grant_access",
+    "hf_hub_download",
+    "hf_hub_url",
+    "hf_raise_for_status",
+    "hffs",
+    "inspect_job",
+    "inspect_scheduled_job",
+    "interpreter_login",
+    "is_offline_mode",
+    "kernel_info",
+    "list_accepted_access_requests",
+    "list_bucket_tree",
+    "list_buckets",
+    "list_collections",
+    "list_daily_papers",
+    "list_dataset_parquet_files",
+    "list_datasets",
+    "list_inference_catalog",
+    "list_inference_endpoints",
+    "list_jobs",
+    "list_jobs_hardware",
+    "list_lfs_files",
+    "list_liked_repos",
+    "list_models",
+    "list_organization_followers",
+    "list_organization_members",
+    "list_papers",
+    "list_pending_access_requests",
+    "list_rejected_access_requests",
+    "list_repo_commits",
+    "list_repo_files",
+    "list_repo_likers",
+    "list_repo_refs",
+    "list_repo_tree",
+    "list_space_templates",
+    "list_spaces",
+    "list_spaces_hardware",
+    "list_user_followers",
+    "list_user_following",
+    "list_user_repos",
+    "list_webhooks",
+    "load_state_dict_from_file",
+    "load_torch_model",
+    "logging",
+    "login",
+    "logout",
+    "merge_pull_request",
+    "metadata_eval_result",
+    "metadata_load",
+    "metadata_save",
+    "metadata_update",
+    "model_info",
+    "move_bucket",
+    "move_repo",
+    "notebook_login",
+    "paper_info",
+    "parse_eval_result_entries",
+    "parse_hf_uri",
+    "parse_huggingface_oauth",
+    "parse_local_safetensors_file_metadata",
+    "parse_safetensors_file_metadata",
+    "pause_inference_endpoint",
+    "pause_space",
+    "permanently_delete_lfs_files",
+    "preupload_lfs_files",
+    "push_to_hub_fastai",
+    "read_dduf_file",
+    "read_paper",
+    "reject_access_request",
+    "rename_discussion",
+    "repo_exists",
+    "repo_info",
+    "repo_type_and_id_from_hf_id",
+    "request_space_hardware",
+    "request_space_storage",
+    "restart_space",
+    "resume_inference_endpoint",
+    "resume_scheduled_job",
+    "revision_exists",
+    "run_as_future",
+    "run_job",
+    "run_uv_job",
+    "save_torch_model",
+    "save_torch_state_dict",
+    "scale_to_zero_inference_endpoint",
+    "scan_cache_dir",
+    "search_spaces",
+    "set_async_client_factory",
+    "set_client_factory",
+    "set_space_sleep_time",
+    "set_space_volumes",
+    "snapshot_download",
+    "space_info",
+    "split_state_dict_into_shards_factory",
+    "split_torch_state_dict_into_shards",
+    "super_squash_history",
+    "suspend_scheduled_job",
+    "sync_bucket",
+    "sync_job_volume",
+    "trigger_scheduled_job",
+    "try_to_load_from_cache",
+    "typer_factory",
+    "unlike",
+    "update_collection_item",
+    "update_collection_metadata",
+    "update_inference_endpoint",
+    "update_job_labels",
+    "update_repo_settings",
+    "update_scheduled_job_labels",
+    "update_webhook",
+    "upload_file",
+    "upload_folder",
+    "upload_large_folder",
+    "verify_repo_checksums",
+    "wait_for_job",
+    "wait_for_space",
+    "webhook_endpoint",
+    "whoami",
+]
+
+
+def _attach(package_name, submodules=None, submod_attrs=None):
+    """Attach lazily loaded submodules, functions, or other attributes.
+
+    Typically, modules import submodules and attributes as follows:
+
+    ```py
+    import mysubmodule
+    import anothersubmodule
+
+    from .foo import someattr
+    ```
+
+    The idea is to replace a package's `__getattr__`, `__dir__`, such that all imports
+    work exactly the way they would with normal imports, except that the import occurs
+    upon first use.
+
+    The typical way to call this function, replacing the above imports, is:
+
+    ```python
+    __getattr__, __dir__ = lazy.attach(
+        __name__,
+        ['mysubmodule', 'anothersubmodule'],
+        {'foo': ['someattr']}
+    )
+    ```
+    This functionality requires Python 3.7 or higher.
+
+    Args:
+        package_name (`str`):
+            Typically use `__name__`.
+        submodules (`set`):
+            List of submodules to attach.
+        submod_attrs (`dict`):
+            Dictionary of submodule -> list of attributes / functions.
+            These attributes are imported as they are used.
+
+    Returns:
+        __getattr__, __dir__, __all__
+
+    """
+    if submod_attrs is None:
+        submod_attrs = {}
+
+    if submodules is None:
+        submodules = set()
+    else:
+        submodules = set(submodules)
+
+    attr_to_modules = {attr: mod for mod, attrs in submod_attrs.items() for attr in attrs}
+
+    def __getattr__(name):
+        if name in submodules:
+            try:
+                return importlib.import_module(f"{package_name}.{name}")
+            except Exception as e:
+                print(f"Error importing {package_name}.{name}: {e}")
+                raise
+        elif name in attr_to_modules:
+            submod_path = f"{package_name}.{attr_to_modules[name]}"
+            try:
+                submod = importlib.import_module(submod_path)
+            except Exception as e:
+                print(f"Error importing {submod_path}: {e}")
+                raise
+            attr = getattr(submod, name)
+
+            # If the attribute lives in a file (module) with the same
+            # name as the attribute, ensure that the attribute and *not*
+            # the module is accessible on the package.
+            if name == attr_to_modules[name]:
+                pkg = sys.modules[package_name]
+                pkg.__dict__[name] = attr
+
+            return attr
+        else:
+            raise AttributeError(f"No {package_name} attribute {name}")
+
+    def __dir__():
+        return __all__
+
+    return __getattr__, __dir__
+
+
+__getattr__, __dir__ = _attach(__name__, submodules=[], submod_attrs=_SUBMOD_ATTRS)
+
+if os.environ.get("EAGER_IMPORT", ""):
+    for attr in __all__:
+        __getattr__(attr)
+
+# WARNING: any content below this statement is generated automatically. Any manual edit
+# will be lost when re-generating this file !
+#
+# To update the static imports, please run the following command and commit the changes.
+# ```
+# # Use script
+# python utils/check_static_imports.py --update
+#
+# # Or run style on codebase
+# make style
+# ```
+if TYPE_CHECKING:  # pragma: no cover
+    from ._buckets import (
+        BucketFile,  # noqa: F401
+        BucketFileMetadata,  # noqa: F401
+        BucketFolder,  # noqa: F401
+        BucketInfo,  # noqa: F401
+        BucketUrl,  # noqa: F401
+        SyncOperation,  # noqa: F401
+        SyncPlan,  # noqa: F401
+    )
+    from ._commit_scheduler import CommitScheduler  # noqa: F401
+    from ._eval_results import (
+        EvalResultEntry,  # noqa: F401
+        eval_result_entries_to_yaml,  # noqa: F401
+        parse_eval_result_entries,  # noqa: F401
+    )
+    from ._inference_endpoints import (
+        InferenceEndpoint,  # noqa: F401
+        InferenceEndpointError,  # noqa: F401
+        InferenceEndpointStatus,  # noqa: F401
+        InferenceEndpointTimeoutError,  # noqa: F401
+        InferenceEndpointType,  # noqa: F401
+    )
+    from ._jobs_api import (
+        JobAccelerator,  # noqa: F401
+        JobDurations,  # noqa: F401
+        JobHardware,  # noqa: F401
+        JobHardwareInfo,  # noqa: F401
+        JobInfo,  # noqa: F401
+        JobInitiator,  # noqa: F401
+        JobOwner,  # noqa: F401
+        JobStage,  # noqa: F401
+        JobStatus,  # noqa: F401
+    )
+    from ._login import (
+        auth_list,  # noqa: F401
+        auth_switch,  # noqa: F401
+        interpreter_login,  # noqa: F401
+        login,  # noqa: F401
+        logout,  # noqa: F401
+        notebook_login,  # noqa: F401
+    )
+    from ._oauth import (
+        OAuthInfo,  # noqa: F401
+        OAuthOrgInfo,  # noqa: F401
+        OAuthUserInfo,  # noqa: F401
+        attach_huggingface_oauth,  # noqa: F401
+        parse_huggingface_oauth,  # noqa: F401
+    )
+    from ._sandbox import (
+        Sandbox,  # noqa: F401
+        SandboxCommandResult,  # noqa: F401
+        SandboxPool,  # noqa: F401
+        SandboxProcess,  # noqa: F401
+    )
+    from ._snapshot_download import (
+        get_cached_repo_tree,  # noqa: F401
+        snapshot_download,  # noqa: F401
+    )
+    from ._space_api import (
+        SpaceHardware,  # noqa: F401
+        SpaceRuntime,  # noqa: F401
+        SpaceSecret,  # noqa: F401
+        SpaceStage,  # noqa: F401
+        SpaceStorage,  # noqa: F401
+        SpaceVariable,  # noqa: F401
+        Volume,  # noqa: F401
+    )
+    from ._tensorboard_logger import HFSummaryWriter  # noqa: F401
+    from ._webhooks_payload import (
+        WebhookPayload,  # noqa: F401
+        WebhookPayloadComment,  # noqa: F401
+        WebhookPayloadDiscussion,  # noqa: F401
+        WebhookPayloadDiscussionChanges,  # noqa: F401
+        WebhookPayloadEvent,  # noqa: F401
+        WebhookPayloadMovedTo,  # noqa: F401
+        WebhookPayloadRepo,  # noqa: F401
+        WebhookPayloadUrl,  # noqa: F401
+        WebhookPayloadWebhook,  # noqa: F401
+    )
+    from ._webhooks_server import (
+        WebhooksServer,  # noqa: F401
+        webhook_endpoint,  # noqa: F401
+    )
+    from .cli._cli_utils import (
+        check_cli_update,  # noqa: F401
+        typer_factory,  # noqa: F401
+    )
+    from .community import (
+        Discussion,  # noqa: F401
+        DiscussionComment,  # noqa: F401
+        DiscussionCommit,  # noqa: F401
+        DiscussionEvent,  # noqa: F401
+        DiscussionStatusChange,  # noqa: F401
+        DiscussionTitleChange,  # noqa: F401
+        DiscussionWithDetails,  # noqa: F401
+    )
+    from .constants import (
+        CONFIG_NAME,  # noqa: F401
+        FLAX_WEIGHTS_NAME,  # noqa: F401
+        HUGGINGFACE_CO_URL_HOME,  # noqa: F401
+        HUGGINGFACE_CO_URL_TEMPLATE,  # noqa: F401
+        PYTORCH_WEIGHTS_NAME,  # noqa: F401
+        REPO_TYPE_DATASET,  # noqa: F401
+        REPO_TYPE_MODEL,  # noqa: F401
+        REPO_TYPE_SPACE,  # noqa: F401
+        TF2_WEIGHTS_NAME,  # noqa: F401
+        TF_WEIGHTS_NAME,  # noqa: F401
+        is_offline_mode,  # noqa: F401
+    )
+    from .fastai_utils import (
+        _save_pretrained_fastai,  # noqa: F401
+        from_pretrained_fastai,  # noqa: F401
+        push_to_hub_fastai,  # noqa: F401
+    )
+    from .file_download import (
+        _CACHED_NO_EXIST,  # noqa: F401
+        DryRunFileInfo,  # noqa: F401
+        HfFileMetadata,  # noqa: F401
+        get_hf_file_metadata,  # noqa: F401
+        hf_hub_download,  # noqa: F401
+        hf_hub_url,  # noqa: F401
+        try_to_load_from_cache,  # noqa: F401
+    )
+    from .hf_api import (
+        Collection,  # noqa: F401
+        CollectionItem,  # noqa: F401
+        CommitInfo,  # noqa: F401
+        CommitOperation,  # noqa: F401
+        CommitOperationAdd,  # noqa: F401
+        CommitOperationCopy,  # noqa: F401
+        CommitOperationDelete,  # noqa: F401
+        DatasetInfo,  # noqa: F401
+        DatasetLeaderboardEntry,  # noqa: F401
+        GitCommitInfo,  # noqa: F401
+        GitRefInfo,  # noqa: F401
+        GitRefs,  # noqa: F401
+        HfApi,  # noqa: F401
+        KernelInfo,  # noqa: F401
+        ModelInfo,  # noqa: F401
+        Organization,  # noqa: F401
+        RepoFile,  # noqa: F401
+        RepoFolder,  # noqa: F401
+        RepoStorageInfo,  # noqa: F401
+        RepoUrl,  # noqa: F401
+        SpaceInfo,  # noqa: F401
+        SpaceSearchResult,  # noqa: F401
+        SpaceTemplate,  # noqa: F401
+        User,  # noqa: F401
+        UserLikes,  # noqa: F401
+        WebhookInfo,  # noqa: F401
+        WebhookWatchedItem,  # noqa: F401
+        accept_access_request,  # noqa: F401
+        add_collection_item,  # noqa: F401
+        add_space_secret,  # noqa: F401
+        add_space_variable,  # noqa: F401
+        auth_check,  # noqa: F401
+        batch_bucket_files,  # noqa: F401
+        bucket_info,  # noqa: F401
+        cancel_access_request,  # noqa: F401
+        cancel_job,  # noqa: F401
+        change_discussion_status,  # noqa: F401
+        comment_discussion,  # noqa: F401
+        copy_files,  # noqa: F401
+        create_branch,  # noqa: F401
+        create_bucket,  # noqa: F401
+        create_collection,  # noqa: F401
+        create_commit,  # noqa: F401
+        create_discussion,  # noqa: F401
+        create_inference_endpoint,  # noqa: F401
+        create_inference_endpoint_from_catalog,  # noqa: F401
+        create_pull_request,  # noqa: F401
+        create_repo,  # noqa: F401
+        create_scheduled_job,  # noqa: F401
+        create_scheduled_uv_job,  # noqa: F401
+        create_tag,  # noqa: F401
+        create_webhook,  # noqa: F401
+        dataset_info,  # noqa: F401
+        delete_branch,  # noqa: F401
+        delete_bucket,  # noqa: F401
+        delete_collection,  # noqa: F401
+        delete_collection_item,  # noqa: F401
+        delete_file,  # noqa: F401
+        delete_folder,  # noqa: F401
+        delete_inference_endpoint,  # noqa: F401
+        delete_repo,  # noqa: F401
+        delete_scheduled_job,  # noqa: F401
+        delete_space_secret,  # noqa: F401
+        delete_space_storage,  # noqa: F401
+        delete_space_variable,  # noqa: F401
+        delete_space_volumes,  # noqa: F401
+        delete_tag,  # noqa: F401
+        delete_webhook,  # noqa: F401
+        disable_space_dev_mode,  # noqa: F401
+        disable_webhook,  # noqa: F401
+        download_bucket_files,  # noqa: F401
+        duplicate_repo,  # noqa: F401
+        duplicate_space,  # noqa: F401
+        edit_discussion_comment,  # noqa: F401
+        enable_space_dev_mode,  # noqa: F401
+        enable_webhook,  # noqa: F401
+        fetch_job_logs,  # noqa: F401
+        fetch_job_metrics,  # noqa: F401
+        fetch_space_logs,  # noqa: F401
+        file_exists,  # noqa: F401
+        get_bucket_file_metadata,  # noqa: F401
+        get_bucket_paths_info,  # noqa: F401
+        get_collection,  # noqa: F401
+        get_dataset_leaderboard,  # noqa: F401
+        get_dataset_tags,  # noqa: F401
+        get_discussion_details,  # noqa: F401
+        get_full_repo_name,  # noqa: F401
+        get_inference_endpoint,  # noqa: F401
+        get_local_safetensors_metadata,  # noqa: F401
+        get_model_tags,  # noqa: F401
+        get_organization_overview,  # noqa: F401
+        get_paths_info,  # noqa: F401
+        get_repo_discussions,  # noqa: F401
+        get_safetensors_metadata,  # noqa: F401
+        get_space_runtime,  # noqa: F401
+        get_space_secrets,  # noqa: F401
+        get_space_variables,  # noqa: F401
+        get_user_overview,  # noqa: F401
+        get_webhook,  # noqa: F401
+        grant_access,  # noqa: F401
+        inspect_job,  # noqa: F401
+        inspect_scheduled_job,  # noqa: F401
+        kernel_info,  # noqa: F401
+        list_accepted_access_requests,  # noqa: F401
+        list_bucket_tree,  # noqa: F401
+        list_buckets,  # noqa: F401
+        list_collections,  # noqa: F401
+        list_daily_papers,  # noqa: F401
+        list_dataset_parquet_files,  # noqa: F401
+        list_datasets,  # noqa: F401
+        list_inference_catalog,  # noqa: F401
+        list_inference_endpoints,  # noqa: F401
+        list_jobs,  # noqa: F401
+        list_jobs_hardware,  # noqa: F401
+        list_lfs_files,  # noqa: F401
+        list_liked_repos,  # noqa: F401
+        list_models,  # noqa: F401
+        list_organization_followers,  # noqa: F401
+        list_organization_members,  # noqa: F401
+        list_papers,  # noqa: F401
+        list_pending_access_requests,  # noqa: F401
+        list_rejected_access_requests,  # noqa: F401
+        list_repo_commits,  # noqa: F401
+        list_repo_files,  # noqa: F401
+        list_repo_likers,  # noqa: F401
+        list_repo_refs,  # noqa: F401
+        list_repo_tree,  # noqa: F401
+        list_space_templates,  # noqa: F401
+        list_spaces,  # noqa: F401
+        list_spaces_hardware,  # noqa: F401
+        list_user_followers,  # noqa: F401
+        list_user_following,  # noqa: F401
+        list_user_repos,  # noqa: F401
+        list_webhooks,  # noqa: F401
+        merge_pull_request,  # noqa: F401
+        model_info,  # noqa: F401
+        move_bucket,  # noqa: F401
+        move_repo,  # noqa: F401
+        paper_info,  # noqa: F401
+        parse_local_safetensors_file_metadata,  # noqa: F401
+        parse_safetensors_file_metadata,  # noqa: F401
+        pause_inference_endpoint,  # noqa: F401
+        pause_space,  # noqa: F401
+        permanently_delete_lfs_files,  # noqa: F401
+        preupload_lfs_files,  # noqa: F401
+        read_paper,  # noqa: F401
+        reject_access_request,  # noqa: F401
+        rename_discussion,  # noqa: F401
+        repo_exists,  # noqa: F401
+        repo_info,  # noqa: F401
+        repo_type_and_id_from_hf_id,  # noqa: F401
+        request_space_hardware,  # noqa: F401
+        request_space_storage,  # noqa: F401
+        restart_space,  # noqa: F401
+        resume_inference_endpoint,  # noqa: F401
+        resume_scheduled_job,  # noqa: F401
+        revision_exists,  # noqa: F401
+        run_as_future,  # noqa: F401
+        run_job,  # noqa: F401
+        run_uv_job,  # noqa: F401
+        scale_to_zero_inference_endpoint,  # noqa: F401
+        search_spaces,  # noqa: F401
+        set_space_sleep_time,  # noqa: F401
+        set_space_volumes,  # noqa: F401
+        space_info,  # noqa: F401
+        super_squash_history,  # noqa: F401
+        suspend_scheduled_job,  # noqa: F401
+        sync_bucket,  # noqa: F401
+        sync_job_volume,  # noqa: F401
+        trigger_scheduled_job,  # noqa: F401
+        unlike,  # noqa: F401
+        update_collection_item,  # noqa: F401
+        update_collection_metadata,  # noqa: F401
+        update_inference_endpoint,  # noqa: F401
+        update_job_labels,  # noqa: F401
+        update_repo_settings,  # noqa: F401
+        update_scheduled_job_labels,  # noqa: F401
+        update_webhook,  # noqa: F401
+        upload_file,  # noqa: F401
+        upload_folder,  # noqa: F401
+        upload_large_folder,  # noqa: F401
+        verify_repo_checksums,  # noqa: F401
+        wait_for_job,  # noqa: F401
+        wait_for_space,  # noqa: F401
+        whoami,  # noqa: F401
+    )
+    from .hf_file_system import (
+        HfFileSystem,  # noqa: F401
+        HfFileSystemFile,  # noqa: F401
+        HfFileSystemResolvedPath,  # noqa: F401
+        HfFileSystemStreamFile,  # noqa: F401
+        hffs,  # noqa: F401
+    )
+    from .hub_mixin import (
+        ModelHubMixin,  # noqa: F401
+        PyTorchModelHubMixin,  # noqa: F401
+    )
+    from .inference._client import (
+        InferenceClient,  # noqa: F401
+        InferenceTimeoutError,  # noqa: F401
+    )
+    from .inference._generated._async_client import AsyncInferenceClient  # noqa: F401
+    from .inference._generated.types import (
+        AudioClassificationInput,  # noqa: F401
+        AudioClassificationOutputElement,  # noqa: F401
+        AudioClassificationOutputTransform,  # noqa: F401
+        AudioClassificationParameters,  # noqa: F401
+        AudioToAudioInput,  # noqa: F401
+        AudioToAudioOutputElement,  # noqa: F401
+        AutomaticSpeechRecognitionEarlyStoppingEnum,  # noqa: F401
+        AutomaticSpeechRecognitionGenerationParameters,  # noqa: F401
+        AutomaticSpeechRecognitionInput,  # noqa: F401
+        AutomaticSpeechRecognitionOutput,  # noqa: F401
+        AutomaticSpeechRecognitionOutputChunk,  # noqa: F401
+        AutomaticSpeechRecognitionParameters,  # noqa: F401
+        ChatCompletionInput,  # noqa: F401
+        ChatCompletionInputFunctionDefinition,  # noqa: F401
+        ChatCompletionInputFunctionName,  # noqa: F401
+        ChatCompletionInputGrammarType,  # noqa: F401
+        ChatCompletionInputJSONSchema,  # noqa: F401
+        ChatCompletionInputMessage,  # noqa: F401
+        ChatCompletionInputMessageChunk,  # noqa: F401
+        ChatCompletionInputMessageChunkType,  # noqa: F401
+        ChatCompletionInputResponseFormatJSONObject,  # noqa: F401
+        ChatCompletionInputResponseFormatJSONSchema,  # noqa: F401
+        ChatCompletionInputResponseFormatText,  # noqa: F401
+        ChatCompletionInputStreamOptions,  # noqa: F401
+        ChatCompletionInputTool,  # noqa: F401
+        ChatCompletionInputToolCall,  # noqa: F401
+        ChatCompletionInputToolChoiceClass,  # noqa: F401
+        ChatCompletionInputToolChoiceEnum,  # noqa: F401
+        ChatCompletionInputURL,  # noqa: F401
+        ChatCompletionOutput,  # noqa: F401
+        ChatCompletionOutputComplete,  # noqa: F401
+        ChatCompletionOutputFunctionDefinition,  # noqa: F401
+        ChatCompletionOutputLogprob,  # noqa: F401
+        ChatCompletionOutputLogprobs,  # noqa: F401
+        ChatCompletionOutputMessage,  # noqa: F401
+        ChatCompletionOutputToolCall,  # noqa: F401
+        ChatCompletionOutputTopLogprob,  # noqa: F401
+        ChatCompletionOutputUsage,  # noqa: F401
+        ChatCompletionStreamOutput,  # noqa: F401
+        ChatCompletionStreamOutputChoice,  # noqa: F401
+        ChatCompletionStreamOutputDelta,  # noqa: F401
+        ChatCompletionStreamOutputDeltaToolCall,  # noqa: F401
+        ChatCompletionStreamOutputFunction,  # noqa: F401
+        ChatCompletionStreamOutputLogprob,  # noqa: F401
+        ChatCompletionStreamOutputLogprobs,  # noqa: F401
+        ChatCompletionStreamOutputTopLogprob,  # noqa: F401
+        ChatCompletionStreamOutputUsage,  # noqa: F401
+        DepthEstimationInput,  # noqa: F401
+        DepthEstimationOutput,  # noqa: F401
+        DocumentQuestionAnsweringInput,  # noqa: F401
+        DocumentQuestionAnsweringInputData,  # noqa: F401
+        DocumentQuestionAnsweringOutputElement,  # noqa: F401
+        DocumentQuestionAnsweringParameters,  # noqa: F401
+        FeatureExtractionInput,  # noqa: F401
+        FeatureExtractionInputTruncationDirection,  # noqa: F401
+        FillMaskInput,  # noqa: F401
+        FillMaskOutputElement,  # noqa: F401
+        FillMaskParameters,  # noqa: F401
+        ImageClassificationInput,  # noqa: F401
+        ImageClassificationOutputElement,  # noqa: F401
+        ImageClassificationOutputTransform,  # noqa: F401
+        ImageClassificationParameters,  # noqa: F401
+        ImageSegmentationInput,  # noqa: F401
+        ImageSegmentationOutputElement,  # noqa: F401
+        ImageSegmentationParameters,  # noqa: F401
+        ImageSegmentationSubtask,  # noqa: F401
+        ImageTextToImageInput,  # noqa: F401
+        ImageTextToImageOutput,  # noqa: F401
+        ImageTextToImageParameters,  # noqa: F401
+        ImageTextToImageTargetSize,  # noqa: F401
+        ImageTextToVideoInput,  # noqa: F401
+        ImageTextToVideoOutput,  # noqa: F401
+        ImageTextToVideoParameters,  # noqa: F401
+        ImageTextToVideoTargetSize,  # noqa: F401
+        ImageToImageInput,  # noqa: F401
+        ImageToImageOutput,  # noqa: F401
+        ImageToImageParameters,  # noqa: F401
+        ImageToImageTargetSize,  # noqa: F401
+        ImageToTextEarlyStoppingEnum,  # noqa: F401
+        ImageToTextGenerationParameters,  # noqa: F401
+        ImageToTextInput,  # noqa: F401
+        ImageToTextOutput,  # noqa: F401
+        ImageToTextParameters,  # noqa: F401
+        ImageToVideoInput,  # noqa: F401
+        ImageToVideoOutput,  # noqa: F401
+        ImageToVideoParameters,  # noqa: F401
+        ImageToVideoTargetSize,  # noqa: F401
+        ObjectDetectionBoundingBox,  # noqa: F401
+        ObjectDetectionInput,  # noqa: F401
+        ObjectDetectionOutputElement,  # noqa: F401
+        ObjectDetectionParameters,  # noqa: F401
+        Padding,  # noqa: F401
+        QuestionAnsweringInput,  # noqa: F401
+        QuestionAnsweringInputData,  # noqa: F401
+        QuestionAnsweringOutputElement,  # noqa: F401
+        QuestionAnsweringParameters,  # noqa: F401
+        SentenceSimilarityInput,  # noqa: F401
+        SentenceSimilarityInputData,  # noqa: F401
+        SummarizationInput,  # noqa: F401
+        SummarizationOutput,  # noqa: F401
+        SummarizationParameters,  # noqa: F401
+        SummarizationTruncationStrategy,  # noqa: F401
+        TableQuestionAnsweringInput,  # noqa: F401
+        TableQuestionAnsweringInputData,  # noqa: F401
+        TableQuestionAnsweringOutputElement,  # noqa: F401
+        TableQuestionAnsweringParameters,  # noqa: F401
+        Text2TextGenerationInput,  # noqa: F401
+        Text2TextGenerationOutput,  # noqa: F401
+        Text2TextGenerationParameters,  # noqa: F401
+        Text2TextGenerationTruncationStrategy,  # noqa: F401
+        TextClassificationInput,  # noqa: F401
+        TextClassificationOutputElement,  # noqa: F401
+        TextClassificationOutputTransform,  # noqa: F401
+        TextClassificationParameters,  # noqa: F401
+        TextGenerationInput,  # noqa: F401
+        TextGenerationInputGenerateParameters,  # noqa: F401
+        TextGenerationInputGrammarType,  # noqa: F401
+        TextGenerationOutput,  # noqa: F401
+        TextGenerationOutputBestOfSequence,  # noqa: F401
+        TextGenerationOutputDetails,  # noqa: F401
+        TextGenerationOutputFinishReason,  # noqa: F401
+        TextGenerationOutputPrefillToken,  # noqa: F401
+        TextGenerationOutputToken,  # noqa: F401
+        TextGenerationStreamOutput,  # noqa: F401
+        TextGenerationStreamOutputStreamDetails,  # noqa: F401
+        TextGenerationStreamOutputToken,  # noqa: F401
+        TextToAudioEarlyStoppingEnum,  # noqa: F401
+        TextToAudioGenerationParameters,  # noqa: F401
+        TextToAudioInput,  # noqa: F401
+        TextToAudioOutput,  # noqa: F401
+        TextToAudioParameters,  # noqa: F401
+        TextToImageInput,  # noqa: F401
+        TextToImageOutput,  # noqa: F401
+        TextToImageParameters,  # noqa: F401
+        TextToSpeechEarlyStoppingEnum,  # noqa: F401
+        TextToSpeechGenerationParameters,  # noqa: F401
+        TextToSpeechInput,  # noqa: F401
+        TextToSpeechOutput,  # noqa: F401
+        TextToSpeechParameters,  # noqa: F401
+        TextToVideoInput,  # noqa: F401
+        TextToVideoOutput,  # noqa: F401
+        TextToVideoParameters,  # noqa: F401
+        TokenClassificationAggregationStrategy,  # noqa: F401
+        TokenClassificationInput,  # noqa: F401
+        TokenClassificationOutputElement,  # noqa: F401
+        TokenClassificationParameters,  # noqa: F401
+        TranslationInput,  # noqa: F401
+        TranslationOutput,  # noqa: F401
+        TranslationParameters,  # noqa: F401
+        TranslationTruncationStrategy,  # noqa: F401
+        TypeEnum,  # noqa: F401
+        VideoClassificationInput,  # noqa: F401
+        VideoClassificationOutputElement,  # noqa: F401
+        VideoClassificationOutputTransform,  # noqa: F401
+        VideoClassificationParameters,  # noqa: F401
+        VisualQuestionAnsweringInput,  # noqa: F401
+        VisualQuestionAnsweringInputData,  # noqa: F401
+        VisualQuestionAnsweringOutputElement,  # noqa: F401
+        VisualQuestionAnsweringParameters,  # noqa: F401
+        ZeroShotClassificationInput,  # noqa: F401
+        ZeroShotClassificationOutputElement,  # noqa: F401
+        ZeroShotClassificationParameters,  # noqa: F401
+        ZeroShotImageClassificationInput,  # noqa: F401
+        ZeroShotImageClassificationOutputElement,  # noqa: F401
+        ZeroShotImageClassificationParameters,  # noqa: F401
+        ZeroShotObjectDetectionBoundingBox,  # noqa: F401
+        ZeroShotObjectDetectionInput,  # noqa: F401
+        ZeroShotObjectDetectionOutputElement,  # noqa: F401
+        ZeroShotObjectDetectionParameters,  # noqa: F401
+    )
+    from .inference._mcp.agent import Agent  # noqa: F401
+    from .inference._mcp.mcp_client import MCPClient  # noqa: F401
+    from .repocard import (
+        DatasetCard,  # noqa: F401
+        ModelCard,  # noqa: F401
+        RepoCard,  # noqa: F401
+        SpaceCard,  # noqa: F401
+        metadata_eval_result,  # noqa: F401
+        metadata_load,  # noqa: F401
+        metadata_save,  # noqa: F401
+        metadata_update,  # noqa: F401
+    )
+    from .repocard_data import (
+        CardData,  # noqa: F401
+        DatasetCardData,  # noqa: F401
+        EvalResult,  # noqa: F401
+        ModelCardData,  # noqa: F401
+        SpaceCardData,  # noqa: F401
+    )
+    from .serialization import (
+        StateDictSplit,  # noqa: F401
+        get_torch_storage_id,  # noqa: F401
+        get_torch_storage_size,  # noqa: F401
+        load_state_dict_from_file,  # noqa: F401
+        load_torch_model,  # noqa: F401
+        save_torch_model,  # noqa: F401
+        save_torch_state_dict,  # noqa: F401
+        split_state_dict_into_shards_factory,  # noqa: F401
+        split_torch_state_dict_into_shards,  # noqa: F401
+    )
+    from .serialization._dduf import (
+        DDUFEntry,  # noqa: F401
+        export_entries_as_dduf,  # noqa: F401
+        export_folder_as_dduf,  # noqa: F401
+        read_dduf_file,  # noqa: F401
+    )
+    from .utils import (
+        ASYNC_CLIENT_FACTORY_T,  # noqa: F401
+        CLIENT_FACTORY_T,  # noqa: F401
+        CachedFileInfo,  # noqa: F401
+        CachedIncompleteFileInfo,  # noqa: F401
+        CachedRepoInfo,  # noqa: F401
+        CachedRevisionInfo,  # noqa: F401
+        CacheNotFound,  # noqa: F401
+        CorruptedCacheException,  # noqa: F401
+        DeleteCacheStrategy,  # noqa: F401
+        HFCacheInfo,  # noqa: F401
+        HfUri,  # noqa: F401
+        cached_assets_path,  # noqa: F401
+        close_session,  # noqa: F401
+        dump_environment_info,  # noqa: F401
+        get_async_session,  # noqa: F401
+        get_session,  # noqa: F401
+        get_token,  # noqa: F401
+        hf_raise_for_status,  # noqa: F401
+        logging,  # noqa: F401
+        parse_hf_uri,  # noqa: F401
+        scan_cache_dir,  # noqa: F401
+        set_async_client_factory,  # noqa: F401
+        set_client_factory,  # noqa: F401
+    )

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_buckets.py

@@ -0,0 +1,1244 @@
+# 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 logic for bucket operations.
+
+This module contains the core buckets logic used by both the CLI and the Python API.
+"""
+
+import fnmatch
+import json
+import mimetypes
+import os
+import stat
+import sys
+import time
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+from . import constants, logging
+from .errors import BucketNotFoundError
+from .utils import (
+    HfUri,
+    StatusLine,
+    XetFileData,
+    disable_progress_bars,
+    enable_progress_bars,
+    parse_datetime,
+    parse_hf_uri,
+)
+from .utils._hf_uris import _looks_like_hf_url
+
+
+if TYPE_CHECKING:
+    from .hf_api import HfApi
+
+
+logger = logging.get_logger(__name__)
+
+
+BUCKET_PREFIX = "hf://buckets/"
+_SYNC_TIME_WINDOW_MS = 1000  # 1s safety-window for file modification time comparisons
+
+
+# =============================================================================
+# Bucket data structures
+# =============================================================================
+
+
+@dataclass
+class BucketInfo:
+    """
+    Contains information about a bucket on the Hub. This object is returned by [`bucket_info`] and [`list_buckets`].
+
+    Attributes:
+        id (`str`):
+            ID of the bucket.
+        private (`bool`):
+            Is the bucket private.
+        created_at (`datetime`):
+            Date of creation of the bucket on the Hub.
+        size (`int`):
+            Size of the bucket in bytes.
+        total_files (`int`):
+            Total number of files in the bucket.
+    """
+
+    id: str
+    private: bool
+    created_at: datetime
+    size: int
+    total_files: int
+
+    def __init__(self, **kwargs):
+        self.id = kwargs.pop("id")
+        self.private = kwargs.pop("private")
+        self.created_at = parse_datetime(kwargs.pop("createdAt"))
+        self.size = kwargs.pop("size")
+        self.total_files = kwargs.pop("totalFiles")
+        self.__dict__.update(**kwargs)
+
+
+@dataclass
+class _BucketAddFile:
+    source: str | Path | bytes
+    destination: str
+
+    xet_hash: str | None = field(default=None)
+    size: int | None = field(default=None)
+    mtime: int = field(init=False)
+    content_type: str | None = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.content_type = None
+        if isinstance(self.source, (str, Path)):  # guess content type from source path
+            self.content_type = mimetypes.guess_type(self.source)[0]
+        if self.content_type is None:  # or default to destination path content type
+            self.content_type = mimetypes.guess_type(self.destination)[0]
+
+        self.mtime = int(
+            os.path.getmtime(self.source) * 1000 if not isinstance(self.source, bytes) else time.time() * 1000
+        )
+
+
+@dataclass
+class _BucketCopyFile:
+    destination: str
+    xet_hash: str
+    source_repo_type: str  # "model", "dataset", "space", "bucket"
+    source_repo_id: str
+    size: int | None = field(default=None)
+    mtime: int = field(init=False)
+    content_type: str | None = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.content_type = mimetypes.guess_type(self.destination)[0]
+        self.mtime = int(time.time() * 1000)
+
+
+@dataclass
+class _BucketDeleteFile:
+    path: str
+
+
+@dataclass(frozen=True)
+class BucketFileMetadata:
+    """Data structure containing information about a file in a bucket.
+
+    Returned by [`get_bucket_file_metadata`].
+
+    Args:
+        size (`int`):
+            Size of the file in bytes.
+        xet_file_data (`XetFileData`):
+            Xet information for the file (hash and refresh route).
+    """
+
+    size: int
+    xet_file_data: XetFileData
+
+
+@dataclass
+class BucketUrl:
+    """Describes a bucket URL on the Hub.
+
+    `BucketUrl` is returned by [`create_bucket`]. At initialization, the URL is parsed to populate properties:
+    - endpoint (`str`)
+    - namespace (`str`)
+    - bucket_id (`str`)
+    - url (`str`)
+    - uri (`HfUri`)
+
+    Args:
+        url (`str`):
+            String value of the bucket url.
+        endpoint (`str`, *optional*):
+            Endpoint of the Hub. Defaults to <https://huggingface.co>.
+    """
+
+    url: str
+    endpoint: str = ""
+    namespace: str = field(init=False)
+    bucket_id: str = field(init=False)
+    uri: HfUri = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.endpoint = self.endpoint or constants.ENDPOINT
+
+        # Parse URL: expected format is `{endpoint}/buckets/{namespace}/{bucket_name}`
+        url_path = self.url.replace(self.endpoint, "").strip("/")
+        # Remove leading "buckets/" prefix
+        if url_path.startswith("buckets/"):
+            url_path = url_path[len("buckets/") :]
+        parsed = _parse_bucket_uri(url_path)
+        if parsed.path_in_repo:
+            raise ValueError(f"Unable to parse bucket URL: {self.url}")
+        self.namespace = parsed.id.split("/")[0]
+        self.bucket_id = parsed.id
+        self.uri = parsed
+
+
+@dataclass
+class BucketFile:
+    """
+    Contains information about a file in a bucket on the Hub. This object is returned by [`list_bucket_tree`].
+
+    Similar to [`RepoFile`] but for files in buckets.
+    """
+
+    type: Literal["file"]
+    path: str
+    size: int
+    xet_hash: str
+    mtime: datetime | None
+    uploaded_at: datetime | None
+
+    def __init__(self, **kwargs):
+        self.type = kwargs.pop("type")
+        self.path = kwargs.pop("path")
+        self.size = kwargs.pop("size")
+        self.xet_hash = kwargs.pop("xetHash")
+        mtime = kwargs.pop("mtime", None)
+        self.mtime = parse_datetime(mtime) if mtime else None
+        uploaded_at = kwargs.pop("uploadedAt", None)
+        self.uploaded_at = parse_datetime(uploaded_at) if uploaded_at else None
+
+
+@dataclass
+class BucketFolder:
+    """
+    Contains information about a directory in a bucket on the Hub. This object is returned by [`list_bucket_tree`].
+
+    Similar to [`RepoFolder`] but for directories in buckets.
+    """
+
+    type: Literal["directory"]
+    path: str
+    uploaded_at: datetime | None
+
+    def __init__(self, **kwargs):
+        self.type = kwargs.pop("type")
+        self.path = kwargs.pop("path")
+        uploaded_at = kwargs.pop("uploadedAt", None) or kwargs.pop("uploaded_at", None)
+        self.uploaded_at = (
+            (uploaded_at if isinstance(uploaded_at, datetime) else parse_datetime(uploaded_at))
+            if uploaded_at
+            else None
+        )
+
+
+# =============================================================================
+# Bucket path parsing
+# =============================================================================
+
+
+def _parse_bucket_uri(path: str) -> HfUri:
+    """Parse a bucket path into a HfUri.
+
+    Accepts:
+    - `hf://buckets/namespace/name(/path/in/repo)` URIs,
+    - Hugging Face web URLs such as `https://huggingface.co/buckets/namespace/name(/tree/path)`,
+    - plain `namespace/name(/path/in/repo)` paths.
+    """
+    if path.startswith(constants.HF_PROTOCOL) or _looks_like_hf_url(path):
+        # Don't use 'if is_hf_uri(...)' here as we prefer 'parse_hf_uri(...)' to raise the exact error message.
+        parsed = parse_hf_uri(path)
+        if not parsed.is_bucket:
+            raise ValueError(f"Invalid bucket path: {path}. Must be a bucket URI (hf://buckets/...).")
+        return parsed
+    parts = path.split("/", 2)
+    if len(parts) < 2 or not parts[0] or not parts[1]:
+        raise ValueError(f"Invalid bucket path: '{path}'. Expected format: namespace/bucket_name")
+    bucket_id = f"{parts[0]}/{parts[1]}"
+    prefix = "/".join(parts[2:])
+    return HfUri(type="bucket", id=bucket_id, path_in_repo=prefix)
+
+
+def _is_bucket_path(path: str) -> bool:
+    """Check if a path is a bucket path.
+
+    Do not raise if the path is not a hf:// URI.
+    Raise if the path is a hf:// URI but with an incorrect format.
+    """
+    if not path.startswith(constants.HF_PROTOCOL):
+        return False
+    return parse_hf_uri(path).is_bucket
+
+
+# =============================================================================
+# Sync data structures
+# =============================================================================
+
+
+@dataclass
+class SyncOperation:
+    """Represents a sync operation to be performed."""
+
+    action: Literal["upload", "download", "delete", "skip"]
+    path: str
+    size: int | None = None
+    reason: str = ""
+    local_mtime: str | None = None
+    remote_mtime: str | None = None
+    bucket_file: BucketFile | None = None  # BucketFile when available (not serialized to plan file)
+
+
+@dataclass
+class SyncPlan:
+    """Represents a complete sync plan."""
+
+    source: str
+    dest: str
+    timestamp: str
+    operations: list[SyncOperation] = field(default_factory=list)
+
+    def summary(self) -> dict[str, int | str]:
+        uploads = sum(1 for op in self.operations if op.action == "upload")
+        downloads = sum(1 for op in self.operations if op.action == "download")
+        deletes = sum(1 for op in self.operations if op.action == "delete")
+        skips = sum(1 for op in self.operations if op.action == "skip")
+        total_size = sum(op.size or 0 for op in self.operations if op.action in ("upload", "download"))
+        return {
+            "uploads": uploads,
+            "downloads": downloads,
+            "deletes": deletes,
+            "skips": skips,
+            "total_size": total_size,
+        }
+
+
+# =============================================================================
+# Filter matching
+# =============================================================================
+
+
+class FilterMatcher:
+    """Matches file paths against include/exclude patterns."""
+
+    def __init__(
+        self,
+        include_patterns: list[str] | None = None,
+        exclude_patterns: list[str] | None = None,
+        filter_rules: list[tuple[str, str]] | None = None,
+    ):
+        """Initialize the filter matcher.
+
+        Args:
+            include_patterns: Patterns to include (from --include)
+            exclude_patterns: Patterns to exclude (from --exclude)
+            filter_rules: Rules from filter file as list of ("+"/"-", pattern) tuples
+        """
+        self.include_patterns = include_patterns or []
+        self.exclude_patterns = exclude_patterns or []
+        self.filter_rules = filter_rules or []
+
+    def matches(self, path: str) -> bool:
+        """Check if a path should be included based on the filter rules.
+
+        Filtering rules:
+        - Filters are evaluated in order, first matching rule decides
+        - If no rules match, include by default (unless include patterns are specified)
+        """
+        # First check filter rules from file (in order)
+        for sign, pattern in self.filter_rules:
+            if fnmatch.fnmatch(path, pattern):
+                return sign == "+"
+
+        # Then check CLI patterns
+        for pattern in self.exclude_patterns:
+            if fnmatch.fnmatch(path, pattern):
+                return False
+
+        for pattern in self.include_patterns:
+            if fnmatch.fnmatch(path, pattern):
+                return True
+
+        # If include patterns were specified but none matched, exclude
+        if self.include_patterns:
+            return False
+
+        # Default: include
+        return True
+
+
+def _parse_filter_file(filter_file: str) -> list[tuple[str, str]]:
+    """Parse a filter file and return a list of (sign, pattern) tuples.
+
+    Filter file format:
+    - Lines starting with "+" are include patterns
+    - Lines starting with "-" are exclude patterns
+    - Empty lines and lines starting with "#" are ignored
+    """
+    rules = []
+    with open(filter_file) as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if line.startswith("+"):
+                rules.append(("+", line[1:].strip()))
+            elif line.startswith("-"):
+                rules.append(("-", line[1:].strip()))
+            else:
+                # Default to include if no prefix
+                rules.append(("+", line))
+    return rules
+
+
+# =============================================================================
+# File listing
+# =============================================================================
+
+
+def _stat_local(path: str) -> tuple[int, float] | None:
+    """Stat a local file and return (size, mtime_ms).
+
+    Returns None if the path is missing or is a directory. Uses a single
+    ``os.stat`` call so callers don't pay for multiple syscalls per file.
+    """
+    try:
+        st = os.stat(path)
+    except OSError:
+        return None
+    if stat.S_ISDIR(st.st_mode):
+        return None
+    return st.st_size, st.st_mtime * 1000
+
+
+def _list_local_files(local_path: str) -> Iterator[tuple[str, int, float]]:
+    """List all files in a local directory.
+
+    Yields:
+        tuple: (relative_path, size, mtime_ms) for each file
+    """
+    local_path = os.path.abspath(local_path)
+    if not os.path.isdir(local_path):
+        raise ValueError(f"Local path must be a directory: {local_path}")
+
+    for root, _, files in os.walk(local_path):
+        for filename in files:
+            full_path = os.path.join(root, filename)
+            stat_info = _stat_local(full_path)
+            if stat_info is None:
+                continue
+            rel_path = os.path.relpath(full_path, local_path)
+            # Normalize to forward slashes for consistency
+            rel_path = rel_path.replace(os.sep, "/")
+            yield rel_path, stat_info[0], stat_info[1]
+
+
+def _list_remote_files(api: "HfApi", bucket_id: str, prefix: str) -> Iterator[tuple[str, int, float, Any]]:
+    """List all files in a bucket with a given prefix.
+
+    Yields:
+        tuple: (relative_path, size, mtime_ms, bucket_file) for each file.
+            bucket_file is the BucketFile object from list_bucket_tree.
+    """
+    for item in api.list_bucket_tree(bucket_id, prefix=prefix or None, recursive=True):
+        if isinstance(item, BucketFolder):
+            continue
+        path = item.path
+        # Remove prefix from path to get relative path
+        # Only strip prefix if it's followed by "/" (directory boundary) or is exact match
+        if prefix:
+            if path.startswith(prefix + "/"):
+                rel_path = path[len(prefix) + 1 :]
+            elif path == prefix:
+                # Exact match: the file IS the prefix (e.g., single file download)
+                rel_path = path.rsplit("/", 1)[-1] if "/" in path else path
+            else:
+                # Path doesn't match prefix pattern (e.g., "submarine.txt" for prefix "sub")
+                # Skip this file - it was returned by the API but doesn't belong to this prefix
+                continue
+        else:
+            rel_path = path
+        mtime_ms = item.mtime.timestamp() * 1000 if item.mtime else 0
+        yield rel_path, item.size, mtime_ms, item
+
+
+# =============================================================================
+# Sync plan computation
+# =============================================================================
+
+
+def _mtime_to_iso(mtime_ms: float) -> str:
+    """Convert mtime in milliseconds to ISO format string."""
+    return datetime.fromtimestamp(mtime_ms / 1000, tz=timezone.utc).isoformat()
+
+
+def _compare_files_for_sync(
+    *,
+    path: str,
+    action: Literal["upload", "download"],
+    source_size: int,
+    source_mtime: float,
+    dest_size: int,
+    dest_mtime: float,
+    source_newer_label: str,
+    dest_newer_label: str,
+    ignore_sizes: bool,
+    ignore_times: bool,
+    ignore_existing: bool,
+    bucket_file: Any | None = None,
+) -> SyncOperation:
+    """Compare source and dest files and return the appropriate sync operation.
+
+    This is a unified helper for both upload and download directions.
+
+    Args:
+        path: Relative file path
+        action: "upload" or "download"
+        source_size: Size of the source file (bytes)
+        source_mtime: Mtime of the source file (milliseconds)
+        dest_size: Size of the destination file (bytes)
+        dest_mtime: Mtime of the destination file (milliseconds)
+        source_newer_label: Label when source is newer (e.g., "local newer" or "remote newer")
+        dest_newer_label: Label when dest is newer (e.g., "remote newer" or "local newer")
+        ignore_sizes: Only compare mtime
+        ignore_times: Only compare size
+        ignore_existing: Skip files that exist on receiver
+        bucket_file: BucketFile object (for downloads only)
+
+    Returns:
+        SyncOperation describing the action to take
+    """
+    local_mtime_iso = _mtime_to_iso(source_mtime if action == "upload" else dest_mtime)
+    remote_mtime_iso = _mtime_to_iso(dest_mtime if action == "upload" else source_mtime)
+
+    base_kwargs: dict[str, Any] = {
+        "path": path,
+        "size": source_size,
+        "local_mtime": local_mtime_iso,
+        "remote_mtime": remote_mtime_iso,
+    }
+
+    if ignore_existing:
+        return SyncOperation(action="skip", reason="exists on receiver (--ignore-existing)", **base_kwargs)
+
+    size_differs = source_size != dest_size
+    source_newer = (source_mtime - dest_mtime) > _SYNC_TIME_WINDOW_MS
+
+    if ignore_sizes:
+        if source_newer:
+            return SyncOperation(action=action, reason=source_newer_label, bucket_file=bucket_file, **base_kwargs)
+        else:
+            dest_newer = (dest_mtime - source_mtime) > _SYNC_TIME_WINDOW_MS
+            skip_reason = dest_newer_label if dest_newer else "same mtime"
+            return SyncOperation(action="skip", reason=skip_reason, **base_kwargs)
+    elif ignore_times:
+        if size_differs:
+            return SyncOperation(action=action, reason="size differs", bucket_file=bucket_file, **base_kwargs)
+        else:
+            return SyncOperation(action="skip", reason="same size", **base_kwargs)
+    else:
+        if size_differs or source_newer:
+            reason = "size differs" if size_differs else source_newer_label
+            return SyncOperation(action=action, reason=reason, bucket_file=bucket_file, **base_kwargs)
+        else:
+            return SyncOperation(action="skip", reason="identical", **base_kwargs)
+
+
+def _compute_sync_plan(
+    source: str,
+    dest: str,
+    api: "HfApi",
+    delete: bool = False,
+    ignore_times: bool = False,
+    ignore_sizes: bool = False,
+    existing: bool = False,
+    ignore_existing: bool = False,
+    filter_matcher: FilterMatcher | None = None,
+    status: Any | None = None,
+) -> SyncPlan:
+    """Compute the sync plan by comparing source and destination.
+
+    Returns:
+        SyncPlan with all operations to be performed
+    """
+    filter_matcher = filter_matcher or FilterMatcher()
+    is_upload = not _is_bucket_path(source) and _is_bucket_path(dest)
+    is_download = _is_bucket_path(source) and not _is_bucket_path(dest)
+
+    if not is_upload and not is_download:
+        raise ValueError("One of source or dest must be a bucket path (hf://buckets/...) and the other must be local.")
+
+    plan = SyncPlan(
+        source=source,
+        dest=dest,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+    )
+
+    remote_total: int | None = None
+    if is_upload:
+        # Local -> Remote
+        local_path = os.path.abspath(source)
+        parsed = _parse_bucket_uri(dest)
+        bucket_id, prefix = parsed.id, parsed.path_in_repo
+
+        if not os.path.isdir(local_path):
+            raise ValueError(f"Source must be a directory: {local_path}")
+
+        # Get local and remote file lists
+        local_files = {}
+        for rel_path, size, mtime_ms in _list_local_files(local_path):
+            if filter_matcher.matches(rel_path):
+                local_files[rel_path] = (size, mtime_ms)
+            if status:
+                status.update(f"Scanning local directory ({len(local_files)} files)")
+        if status:
+            status.done(f"Scanning local directory ({len(local_files)} files)")
+
+        remote_files = {}
+        if status:
+            try:
+                remote_total = api.bucket_info(bucket_id).total_files
+            except Exception:
+                pass
+        try:
+            for rel_path, size, mtime_ms, _ in _list_remote_files(api, bucket_id, prefix):
+                if filter_matcher.matches(rel_path):
+                    remote_files[rel_path] = (size, mtime_ms)
+                if status:
+                    total_str = f"/{remote_total}" if remote_total is not None else ""
+                    status.update(f"Scanning remote bucket ({len(remote_files)}{total_str} files)")
+        except BucketNotFoundError:
+            # Bucket doesn't exist yet - this is expected for new uploads
+            logger.debug(f"Bucket '{bucket_id}' not found, treating as empty.")
+        if status:
+            status.done(f"Scanning remote bucket ({len(remote_files)} files)")
+
+        # Compare files
+        all_paths = set(local_files.keys()) | set(remote_files.keys())
+        if status:
+            status.done(f"Comparing files ({len(all_paths)} paths)")
+        for path in sorted(all_paths):
+            local_info = local_files.get(path)
+            remote_info = remote_files.get(path)
+
+            if local_info and not remote_info:
+                # New file
+                if existing:
+                    # --existing: skip new files
+                    plan.operations.append(
+                        SyncOperation(
+                            action="skip",
+                            path=path,
+                            size=local_info[0],
+                            reason="new file (--existing)",
+                            local_mtime=_mtime_to_iso(local_info[1]),
+                        )
+                    )
+                else:
+                    plan.operations.append(
+                        SyncOperation(
+                            action="upload",
+                            path=path,
+                            size=local_info[0],
+                            reason="new file",
+                            local_mtime=_mtime_to_iso(local_info[1]),
+                        )
+                    )
+            elif local_info and remote_info:
+                # File exists in both - use helper to determine action
+                local_size, local_mtime = local_info
+                remote_size, remote_mtime = remote_info
+                plan.operations.append(
+                    _compare_files_for_sync(
+                        path=path,
+                        action="upload",
+                        source_size=local_size,
+                        source_mtime=local_mtime,
+                        dest_size=remote_size,
+                        dest_mtime=remote_mtime,
+                        source_newer_label="local newer",
+                        dest_newer_label="remote newer",
+                        ignore_sizes=ignore_sizes,
+                        ignore_times=ignore_times,
+                        ignore_existing=ignore_existing,
+                    )
+                )
+            elif not local_info and remote_info and delete:
+                # File only in remote and --delete mode
+                plan.operations.append(
+                    SyncOperation(
+                        action="delete",
+                        path=path,
+                        size=remote_info[0],
+                        reason="not in source (--delete)",
+                        remote_mtime=_mtime_to_iso(remote_info[1]),
+                    )
+                )
+
+    else:
+        # Remote -> Local (download)
+        parsed = _parse_bucket_uri(source)
+        bucket_id, prefix = parsed.id, parsed.path_in_repo
+        local_path = os.path.abspath(dest)
+
+        # Get remote and local file lists
+        remote_files = {}
+        bucket_file_map: dict[str, Any] = {}
+        if status:
+            try:
+                remote_total = api.bucket_info(bucket_id).total_files
+            except Exception:
+                pass
+        for rel_path, size, mtime_ms, bucket_file in _list_remote_files(api, bucket_id, prefix):
+            if filter_matcher.matches(rel_path):
+                remote_files[rel_path] = (size, mtime_ms)
+                bucket_file_map[rel_path] = bucket_file
+            if status:
+                total_str = f"/{remote_total}" if remote_total is not None else ""
+                status.update(f"Scanning remote bucket ({len(remote_files)}{total_str} files)")
+        if status:
+            status.done(f"Scanning remote bucket ({len(remote_files)} files)")
+
+        local_files = {}
+        if os.path.isdir(local_path):
+            if delete:
+                # Full walk needed to discover local-only files for deletion.
+                for rel_path, size, mtime_ms in _list_local_files(local_path):
+                    if filter_matcher.matches(rel_path):
+                        local_files[rel_path] = (size, mtime_ms)
+                    if status:
+                        status.update(f"Scanning local directory ({len(local_files)} files)")
+            else:
+                # Without --delete, the plan only depends on paths that exist
+                # remotely. Stat just those instead of walking the whole tree,
+                # which can take minutes when dest sits in a large directory
+                # like ~/.cache/huggingface/.
+                for rel_path in remote_files:
+                    local_file = os.path.join(local_path, rel_path)
+                    stat_info = _stat_local(local_file)
+                    if stat_info is None:
+                        continue
+                    local_files[rel_path] = stat_info
+                    if status:
+                        status.update(f"Scanning local directory ({len(local_files)} files)")
+        if status:
+            status.done(f"Scanning local directory ({len(local_files)} files)")
+
+        # Compare files
+        all_paths = set(remote_files.keys()) | set(local_files.keys())
+        if status:
+            status.done(f"Comparing files ({len(all_paths)} paths)")
+        for path in sorted(all_paths):
+            remote_info = remote_files.get(path)
+            local_info = local_files.get(path)
+
+            if remote_info and not local_info:
+                # New file
+                if existing:
+                    # --existing: skip new files
+                    plan.operations.append(
+                        SyncOperation(
+                            action="skip",
+                            path=path,
+                            size=remote_info[0],
+                            reason="new file (--existing)",
+                            remote_mtime=_mtime_to_iso(remote_info[1]),
+                        )
+                    )
+                else:
+                    plan.operations.append(
+                        SyncOperation(
+                            action="download",
+                            path=path,
+                            size=remote_info[0],
+                            reason="new file",
+                            remote_mtime=_mtime_to_iso(remote_info[1]),
+                            bucket_file=bucket_file_map.get(path),
+                        )
+                    )
+            elif remote_info and local_info:
+                # File exists in both - use helper to determine action
+                remote_size, remote_mtime = remote_info
+                local_size, local_mtime = local_info
+                plan.operations.append(
+                    _compare_files_for_sync(
+                        path=path,
+                        action="download",
+                        source_size=remote_size,
+                        source_mtime=remote_mtime,
+                        dest_size=local_size,
+                        dest_mtime=local_mtime,
+                        source_newer_label="remote newer",
+                        dest_newer_label="local newer",
+                        ignore_sizes=ignore_sizes,
+                        ignore_times=ignore_times,
+                        ignore_existing=ignore_existing,
+                        bucket_file=bucket_file_map.get(path),
+                    )
+                )
+            elif not remote_info and local_info and delete:
+                # File only in local and --delete mode
+                plan.operations.append(
+                    SyncOperation(
+                        action="delete",
+                        path=path,
+                        size=local_info[0],
+                        reason="not in source (--delete)",
+                        local_mtime=_mtime_to_iso(local_info[1]),
+                    )
+                )
+
+    return plan
+
+
+# =============================================================================
+# Plan serialization
+# =============================================================================
+
+
+def _write_plan(plan: SyncPlan, f) -> None:
+    """Write a sync plan as JSONL to a file-like object."""
+    # Write header
+    header = {
+        "type": "header",
+        "source": plan.source,
+        "dest": plan.dest,
+        "timestamp": plan.timestamp,
+        "summary": plan.summary(),
+    }
+    f.write(json.dumps(header) + "\n")
+
+    # Write operations
+    for op in plan.operations:
+        op_dict: dict[str, Any] = {
+            "type": "operation",
+            "action": op.action,
+            "path": op.path,
+            "reason": op.reason,
+        }
+        if op.size is not None:
+            op_dict["size"] = op.size
+        if op.local_mtime is not None:
+            op_dict["local_mtime"] = op.local_mtime
+        if op.remote_mtime is not None:
+            op_dict["remote_mtime"] = op.remote_mtime
+        f.write(json.dumps(op_dict) + "\n")
+
+
+def _save_plan(plan: SyncPlan, plan_file: str) -> None:
+    """Save a sync plan to a JSONL file."""
+    with open(plan_file, "w") as f:
+        _write_plan(plan, f)
+
+
+def _load_plan(plan_file: str) -> SyncPlan:
+    """Load a sync plan from a JSONL file."""
+    with open(plan_file) as f:
+        lines = f.readlines()
+
+    if not lines:
+        raise ValueError(f"Empty plan file: {plan_file}")
+
+    # Parse header
+    header = json.loads(lines[0])
+    if header.get("type") != "header":
+        raise ValueError("Invalid plan file: expected header as first line")
+
+    plan = SyncPlan(
+        source=header["source"],
+        dest=header["dest"],
+        timestamp=header["timestamp"],
+    )
+
+    # Parse operations
+    for line in lines[1:]:
+        op_dict = json.loads(line)
+        if op_dict.get("type") != "operation":
+            continue
+        plan.operations.append(
+            SyncOperation(
+                action=op_dict["action"],
+                path=op_dict["path"],
+                size=op_dict.get("size"),
+                reason=op_dict.get("reason", ""),
+                local_mtime=op_dict.get("local_mtime"),
+                remote_mtime=op_dict.get("remote_mtime"),
+            )
+        )
+
+    return plan
+
+
+# =============================================================================
+# Plan execution
+# =============================================================================
+
+
+def _execute_plan(plan: SyncPlan, api: "HfApi", verbose: bool = False, status: Any | None = None) -> None:
+    """Execute a sync plan."""
+    is_upload = not _is_bucket_path(plan.source) and _is_bucket_path(plan.dest)
+    is_download = _is_bucket_path(plan.source) and not _is_bucket_path(plan.dest)
+
+    if is_upload:
+        local_path = os.path.abspath(plan.source)
+        parsed = _parse_bucket_uri(plan.dest)
+        bucket_id, prefix = parsed.id, parsed.path_in_repo
+
+        # Collect operations
+        add_files: list[tuple[str | Path | bytes, str]] = []
+        delete_paths: list[str] = []
+
+        for op in plan.operations:
+            match op.action:
+                case "upload":
+                    local_file = os.path.join(local_path, op.path)
+                    remote_path = f"{prefix}/{op.path}" if prefix else op.path
+                    if verbose:
+                        print(f"  Uploading: {op.path} ({op.reason})")
+                    add_files.append((local_file, remote_path))
+                case "delete":
+                    remote_path = f"{prefix}/{op.path}" if prefix else op.path
+                    if verbose:
+                        print(f"  Deleting: {op.path} ({op.reason})")
+                    delete_paths.append(remote_path)
+                case "skip" if verbose:
+                    print(f"  Skipping: {op.path} ({op.reason})")
+
+        # Execute batch operations
+        if add_files or delete_paths:
+            if status:
+                parts = []
+                if add_files:
+                    parts.append(f"uploading {len(add_files)} files")
+                if delete_paths:
+                    parts.append(f"deleting {len(delete_paths)} files")
+                status.done(", ".join(parts).capitalize())
+            api.batch_bucket_files(
+                bucket_id,
+                add=add_files or None,
+                delete=delete_paths or None,
+            )
+
+    elif is_download:
+        parsed = _parse_bucket_uri(plan.source)
+        bucket_id, prefix = parsed.id, parsed.path_in_repo
+        local_path = os.path.abspath(plan.dest)
+
+        # Ensure local directory exists
+        os.makedirs(local_path, exist_ok=True)
+
+        # Collect download operations
+        download_files: list[tuple[str | BucketFile, str | Path]] = []
+        delete_files: list[str] = []
+
+        for op in plan.operations:
+            if op.action == "download":
+                local_file = os.path.join(local_path, op.path)
+                # Ensure parent directory exists
+                os.makedirs(os.path.dirname(local_file), exist_ok=True)
+                if verbose:
+                    print(f"  Downloading: {op.path} ({op.reason})")
+                # Use BucketFile when available (avoids extra metadata fetch per file)
+                if op.bucket_file is not None:
+                    download_files.append((op.bucket_file, local_file))
+                else:
+                    remote_path = f"{prefix}/{op.path}" if prefix else op.path
+                    download_files.append((remote_path, local_file))
+            elif op.action == "delete":
+                local_file = os.path.join(local_path, op.path)
+                if verbose:
+                    print(f"  Deleting: {op.path} ({op.reason})")
+                delete_files.append(local_file)
+            elif op.action == "skip" and verbose:
+                print(f"  Skipping: {op.path} ({op.reason})")
+
+        # Execute downloads
+        if len(download_files) > 0:
+            if status:
+                status.done(f"Downloading {len(download_files)} files")
+            api.download_bucket_files(bucket_id, download_files)
+
+        # Execute deletes
+        if status and delete_files:
+            status.done(f"Deleting {len(delete_files)} local files")
+        for file_path in delete_files:
+            if os.path.exists(file_path):
+                os.remove(file_path)
+                # Remove empty parent directories
+                parent = os.path.dirname(file_path)
+                while parent != local_path:
+                    try:
+                        os.rmdir(parent)
+                        parent = os.path.dirname(parent)
+                    except OSError:
+                        break
+
+
+def _print_plan_summary(plan: SyncPlan) -> None:
+    """Print a summary of the sync plan."""
+    summary = plan.summary()
+    print(f"Sync plan: {plan.source} -> {plan.dest}")
+    print(f"  Uploads: {summary['uploads']}")
+    print(f"  Downloads: {summary['downloads']}")
+    print(f"  Deletes: {summary['deletes']}")
+    print(f"  Skips: {summary['skips']}")
+
+
+# =============================================================================
+# Public sync function (Python API)
+# =============================================================================
+
+
+def sync_bucket_internal(
+    source: str | None = None,
+    dest: str | None = None,
+    *,
+    api: "HfApi",
+    delete: bool = False,
+    ignore_times: bool = False,
+    ignore_sizes: bool = False,
+    existing: bool = False,
+    ignore_existing: bool = False,
+    include: list[str] | None = None,
+    exclude: list[str] | None = None,
+    filter_from: str | None = None,
+    plan: str | None = None,
+    apply: str | None = None,
+    dry_run: bool = False,
+    verbose: bool = False,
+    quiet: bool = False,
+    token: bool | str | None = None,
+) -> SyncPlan:
+    """Sync files between a local directory and a bucket.
+
+    This is equivalent to the ``hf buckets sync`` CLI command. One of ``source`` or ``dest`` must be a bucket path
+    (``hf://buckets/...``) and the other must be a local directory path.
+
+    Args:
+        source (`str`, *optional*):
+            Source path: local directory or ``hf://buckets/namespace/bucket_name(/prefix)``.
+            Required unless using ``apply``.
+        dest (`str`, *optional*):
+            Destination path: local directory or ``hf://buckets/namespace/bucket_name(/prefix)``.
+            Required unless using ``apply``.
+        api ([`HfApi`]):
+            The HfApi instance to use for API calls.
+        delete (`bool`, *optional*, defaults to `False`):
+            Delete destination files not present in source.
+        ignore_times (`bool`, *optional*, defaults to `False`):
+            Skip files only based on size, ignoring modification times.
+        ignore_sizes (`bool`, *optional*, defaults to `False`):
+            Skip files only based on modification times, ignoring sizes.
+        existing (`bool`, *optional*, defaults to `False`):
+            Skip creating new files on receiver (only update existing files).
+        ignore_existing (`bool`, *optional*, defaults to `False`):
+            Skip updating files that exist on receiver (only create new files).
+        include (`list[str]`, *optional*):
+            Include files matching patterns (fnmatch-style).
+        exclude (`list[str]`, *optional*):
+            Exclude files matching patterns (fnmatch-style).
+        filter_from (`str`, *optional*):
+            Path to a filter file with include/exclude rules.
+        plan (`str`, *optional*):
+            Save sync plan to this JSONL file instead of executing.
+        apply (`str`, *optional*):
+            Apply a previously saved plan file. When set, ``source`` and ``dest`` are not needed.
+        dry_run (`bool`, *optional*, defaults to `False`):
+            Print sync plan to stdout as JSONL without executing.
+        verbose (`bool`, *optional*, defaults to `False`):
+            Show detailed per-file operations.
+        quiet (`bool`, *optional*, defaults to `False`):
+            Suppress all output and progress bars.
+        token (Union[bool, str, None], optional):
+            A valid user access token. If not provided, the locally saved token will be used.
+
+    Returns:
+        [`SyncPlan`]: The computed (or loaded) sync plan.
+
+    Raises:
+        `ValueError`: If arguments are invalid (e.g., both paths are remote, conflicting options).
+
+    Example:
+        ```python
+        >>> from huggingface_hub import HfApi
+        >>> api = HfApi()
+
+        # Upload local directory to bucket
+        >>> api.sync_bucket("./data", "hf://buckets/username/my-bucket")
+
+        # Download bucket to local directory
+        >>> api.sync_bucket("hf://buckets/username/my-bucket", "./data")
+
+        # Sync with delete and filtering
+        >>> api.sync_bucket(
+        ...     "./data",
+        ...     "hf://buckets/username/my-bucket",
+        ...     delete=True,
+        ...     include=["*.safetensors"],
+        ... )
+
+        # Dry run: preview what would be synced
+        >>> plan = api.sync_bucket("./data", "hf://buckets/username/my-bucket", dry_run=True)
+        >>> plan.summary()
+        {'uploads': 3, 'downloads': 0, 'deletes': 0, 'skips': 1, 'total_size': 4096}
+
+        # Save plan for review, then apply
+        >>> api.sync_bucket("./data", "hf://buckets/username/my-bucket", plan="sync-plan.jsonl")
+        >>> api.sync_bucket(apply="sync-plan.jsonl")
+        ```
+    """
+    # Build API with token if needed
+    if token is not None:
+        from .hf_api import HfApi
+
+        api = HfApi(
+            endpoint=api.endpoint,
+            token=token,
+            library_name=api.library_name,
+            library_version=api.library_version,
+            user_agent=api.user_agent,
+            headers=api.headers,
+        )
+    # --- Apply mode ---
+    if apply:
+        if source or dest:
+            raise ValueError("Cannot specify source/dest when using apply.")
+        if plan is not None:
+            raise ValueError("Cannot specify both plan and apply.")
+        if delete:
+            raise ValueError("Cannot specify delete when using apply.")
+        if ignore_times:
+            raise ValueError("Cannot specify ignore_times when using apply.")
+        if ignore_sizes:
+            raise ValueError("Cannot specify ignore_sizes when using apply.")
+        if include:
+            raise ValueError("Cannot specify include when using apply.")
+        if exclude:
+            raise ValueError("Cannot specify exclude when using apply.")
+        if filter_from:
+            raise ValueError("Cannot specify filter_from when using apply.")
+        if existing:
+            raise ValueError("Cannot specify existing when using apply.")
+        if ignore_existing:
+            raise ValueError("Cannot specify ignore_existing when using apply.")
+        if dry_run:
+            raise ValueError("Cannot specify dry_run when using apply.")
+
+        sync_plan = _load_plan(apply)
+        status = StatusLine(enabled=not quiet)
+        if not quiet:
+            _print_plan_summary(sync_plan)
+            print("Executing plan...")
+
+        if quiet:
+            disable_progress_bars()
+        try:
+            _execute_plan(sync_plan, api, verbose=verbose, status=status)
+        finally:
+            if quiet:
+                enable_progress_bars()
+
+        if not quiet:
+            print("Sync completed.")
+
+        return sync_plan
+
+    # --- Normal mode ---
+    if not source or not dest:
+        raise ValueError("Both source and dest are required (unless using apply).")
+
+    source_is_bucket = _is_bucket_path(source)
+    dest_is_bucket = _is_bucket_path(dest)
+
+    if source_is_bucket and dest_is_bucket:
+        raise ValueError("Remote to remote sync is not supported. One path must be local.")
+
+    if not source_is_bucket and not dest_is_bucket:
+        raise ValueError("One of source or dest must be a bucket path (hf://buckets/...).")
+
+    if ignore_times and ignore_sizes:
+        raise ValueError("Cannot specify both ignore_times and ignore_sizes.")
+
+    if existing and ignore_existing:
+        raise ValueError("Cannot specify both existing and ignore_existing.")
+
+    if dry_run and plan:
+        raise ValueError("Cannot specify both dry_run and plan.")
+
+    # Validate local path
+    if source_is_bucket:
+        if os.path.exists(dest) and not os.path.isdir(dest):
+            raise ValueError(f"Destination must be a directory: {dest}")
+    else:
+        if not os.path.isdir(source):
+            raise ValueError(f"Source must be an existing directory: {source}")
+
+    # Build filter matcher
+    filter_rules = None
+    if filter_from:
+        filter_rules = _parse_filter_file(filter_from)
+
+    filter_matcher = FilterMatcher(
+        include_patterns=include,
+        exclude_patterns=exclude,
+        filter_rules=filter_rules,
+    )
+
+    # Compute sync plan
+    status = StatusLine(enabled=not quiet and not dry_run)
+    sync_plan = _compute_sync_plan(
+        source=source,
+        dest=dest,
+        api=api,
+        delete=delete,
+        ignore_times=ignore_times,
+        ignore_sizes=ignore_sizes,
+        existing=existing,
+        ignore_existing=ignore_existing,
+        filter_matcher=filter_matcher,
+        status=status,
+    )
+
+    if dry_run:
+        _write_plan(sync_plan, sys.stdout)
+        return sync_plan
+
+    if plan:
+        _save_plan(sync_plan, plan)
+        if not quiet:
+            _print_plan_summary(sync_plan)
+            print(f"Plan saved to: {plan}")
+        return sync_plan
+
+    # Execute plan
+    if not quiet:
+        _print_plan_summary(sync_plan)
+
+    summary = sync_plan.summary()
+    if summary["uploads"] == 0 and summary["downloads"] == 0 and summary["deletes"] == 0:
+        if not quiet:
+            print("Nothing to sync.")
+        return sync_plan
+
+    if not quiet:
+        print("Syncing...")
+
+    if quiet:
+        disable_progress_bars()
+    try:
+        _execute_plan(sync_plan, api, verbose=verbose, status=status)
+    finally:
+        if quiet:
+            enable_progress_bars()
+
+    if not quiet:
+        print("Sync completed.")
+
+    return sync_plan

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_commit_api.py

@@ -0,0 +1,1075 @@
+"""
+Type definitions and utilities for the `create_commit` API
+"""
+
+import base64
+import io
+import json
+import os
+import warnings
+from collections import defaultdict
+from collections.abc import Iterable, Iterator
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from itertools import groupby
+from pathlib import Path, PurePosixPath
+from typing import TYPE_CHECKING, Any, BinaryIO, Literal, NamedTuple, Union
+
+from tqdm.contrib.concurrent import thread_map
+
+from . import constants
+from .errors import EntryNotFoundError
+from .file_download import hf_hub_url
+from .lfs import UploadInfo, lfs_upload, post_lfs_batch_info
+from .utils import (
+    FORBIDDEN_FOLDERS,
+    are_progress_bars_disabled,
+    chunk_iterable,
+    get_session,
+    hf_raise_for_status,
+    http_backoff,
+    logging,
+    sha,
+    tqdm_stream_file,
+    validate_hf_hub_args,
+)
+from .utils import tqdm as hf_tqdm
+from .utils._runtime import is_xet_available
+
+
+if TYPE_CHECKING:
+    from .hf_api import CommitInfo, RepoFile
+
+
+logger = logging.get_logger(__name__)
+
+
+UploadMode = Literal["lfs", "regular"]
+
+# Max is 1,000 per request on the Hub for HfApi.get_paths_info
+# Otherwise we get:
+# HfHubHTTPError: 413 Client Error: Payload Too Large for url: https://huggingface.co/api/datasets/xxx (Request ID: xxx)\n\ntoo many parameters
+# See https://github.com/huggingface/huggingface_hub/issues/1503
+FETCH_LFS_BATCH_SIZE = 500
+DUPLICATE_LFS_BATCH_SIZE = 500
+
+UPLOAD_BATCH_MAX_NUM_FILES = 256
+
+
+@dataclass
+class CommitOperationDelete:
+    """
+    Data structure holding necessary info to delete a file or a folder from a repository
+    on the Hub.
+
+    Args:
+        path_in_repo (`str`):
+            Relative filepath in the repo, for example: `"checkpoints/1fec34a/weights.bin"`
+            for a file or `"checkpoints/1fec34a/"` for a folder.
+        is_folder (`bool` or `Literal["auto"]`, *optional*)
+            Whether the Delete Operation applies to a folder or not. If "auto", the path
+            type (file or folder) is guessed automatically by looking if path ends with
+            a "/" (folder) or not (file). To explicitly set the path type, you can set
+            `is_folder=True` or `is_folder=False`.
+    """
+
+    path_in_repo: str
+    is_folder: bool | Literal["auto"] = "auto"
+
+    def __post_init__(self):
+        self.path_in_repo = _validate_path_in_repo(self.path_in_repo)
+
+        if self.is_folder == "auto":
+            self.is_folder = self.path_in_repo.endswith("/")
+        if not isinstance(self.is_folder, bool):
+            raise ValueError(
+                f"Wrong value for `is_folder`. Must be one of [`True`, `False`, `'auto'`]. Got '{self.is_folder}'."
+            )
+
+
+@dataclass
+class CommitOperationCopy:
+    """
+    Data structure holding necessary info to copy a file in a repository on the Hub.
+
+    Both LFS files and regular files are supported. LFS files are copied server-side while regular files are
+    downloaded and re-uploaded as part of the commit.
+
+    Cross-repository copies are supported by setting `src_repo_id` and `src_repo_type`. For cross-repo LFS copies,
+    the LFS objects are duplicated to the destination repository before the commit is created. This is handled
+    automatically by [`create_commit`]. Note that cross-repository copies only work within the same
+    [storage region](https://huggingface.co/docs/hub/storage-regions); copying across regions is not supported.
+
+    Note: you can combine a [`CommitOperationCopy`] and a [`CommitOperationDelete`] to rename an LFS file on the Hub.
+
+    Args:
+        src_path_in_repo (`str`):
+            Relative filepath in the repo of the file to be copied, e.g. `"checkpoints/1fec34a/weights.bin"`.
+        path_in_repo (`str`):
+            Relative filepath in the repo where to copy the file, e.g. `"checkpoints/1fec34a/weights_copy.bin"`.
+        src_revision (`str`, *optional*):
+            The git revision of the file to be copied. Can be any valid git revision.
+            Default to the target commit revision.
+        src_repo_id (`str`, *optional*):
+            The source repository to copy from (e.g. `"username/source-model"`).
+            Default to the destination repository (intra-repo copy).
+        src_repo_type (`str`, *optional*):
+            The type of the source repository (`"model"`, `"dataset"` or `"space"`).
+            Required when `src_repo_id` is set.
+    """
+
+    src_path_in_repo: str
+    path_in_repo: str
+    src_revision: str | None = None
+    src_repo_id: str | None = None
+    src_repo_type: str | None = None
+    # set to the OID of the file to be copied if it has already been uploaded
+    # useful to determine if a commit will be empty or not.
+    _src_oid: str | None = None
+    # set to the OID of the file to copy to if it has already been uploaded
+    # useful to determine if a commit will be empty or not.
+    _dest_oid: str | None = None
+    # set to True once cross-repo LFS files have been duplicated to the destination repo
+    _is_duplicated: bool = False
+
+    def __post_init__(self):
+        self.src_path_in_repo = _validate_path_in_repo(self.src_path_in_repo)
+        self.path_in_repo = _validate_path_in_repo(self.path_in_repo)
+        if self.src_repo_id is not None and self.src_repo_type is None:
+            raise ValueError("`src_repo_type` is required when `src_repo_id` is set.")
+        if self.src_repo_type is not None and self.src_repo_id is None:
+            raise ValueError("`src_repo_id` is required when `src_repo_type` is set.")
+
+
+@dataclass
+class CommitOperationAdd:
+    """
+    Data structure holding necessary info to upload a file to a repository on the Hub.
+
+    Args:
+        path_in_repo (`str`):
+            Relative filepath in the repo, for example: `"checkpoints/1fec34a/weights.bin"`
+        path_or_fileobj (`str`, `Path`, `bytes`, or `BinaryIO`):
+            Either:
+            - a path to a local file (as `str` or `pathlib.Path`) to upload
+            - a buffer of bytes (`bytes`) holding the content of the file to upload
+            - a "file object" (subclass of `io.BufferedIOBase`), typically obtained
+                with `open(path, "rb")`. It must support `seek()` and `tell()` methods.
+
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `path_or_fileobj` is not one of `str`, `Path`, `bytes` or `io.BufferedIOBase`.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `path_or_fileobj` is a `str` or `Path` but not a path to an existing file.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `path_or_fileobj` is a `io.BufferedIOBase` but it doesn't support both
+            `seek()` and `tell()`.
+    """
+
+    path_in_repo: str
+    path_or_fileobj: str | Path | bytes | BinaryIO
+    upload_info: UploadInfo = field(init=False, repr=False)
+
+    # Internal attributes
+
+    # set to "lfs" or "regular" once known
+    _upload_mode: UploadMode | None = field(init=False, repr=False, default=None)
+
+    # set to True if .gitignore rules prevent the file from being uploaded as LFS
+    # (server-side check)
+    _should_ignore: bool | None = field(init=False, repr=False, default=None)
+
+    # set to the remote OID of the file if it has already been uploaded
+    # useful to determine if a commit will be empty or not
+    _remote_oid: str | None = field(init=False, repr=False, default=None)
+
+    # set to True once the file has been uploaded as LFS
+    _is_uploaded: bool = field(init=False, repr=False, default=False)
+
+    # set to True once the file has been committed
+    _is_committed: bool = field(init=False, repr=False, default=False)
+
+    def __post_init__(self) -> None:
+        """Validates `path_or_fileobj` and compute `upload_info`."""
+        self.path_in_repo = _validate_path_in_repo(self.path_in_repo)
+
+        # Validate `path_or_fileobj` value
+        if isinstance(self.path_or_fileobj, Path):
+            self.path_or_fileobj = str(self.path_or_fileobj)
+        if isinstance(self.path_or_fileobj, str):
+            path_or_fileobj = os.path.normpath(os.path.expanduser(self.path_or_fileobj))
+            if not os.path.isfile(path_or_fileobj):
+                raise ValueError(f"Provided path: '{path_or_fileobj}' is not a file on the local file system")
+        elif not isinstance(self.path_or_fileobj, (io.BufferedIOBase, bytes)):
+            # ^^ Inspired from: https://stackoverflow.com/questions/44584829/how-to-determine-if-file-is-opened-in-binary-or-text-mode
+            raise ValueError(
+                "path_or_fileobj must be either an instance of str, bytes or"
+                " io.BufferedIOBase. If you passed a file-like object, make sure it is"
+                " in binary mode."
+            )
+        if isinstance(self.path_or_fileobj, io.BufferedIOBase):
+            try:
+                self.path_or_fileobj.tell()
+                self.path_or_fileobj.seek(0, os.SEEK_CUR)
+            except (OSError, AttributeError) as exc:
+                raise ValueError(
+                    "path_or_fileobj is a file-like object but does not implement seek() and tell()"
+                ) from exc
+
+        # Compute "upload_info" attribute
+        if isinstance(self.path_or_fileobj, str):
+            self.upload_info = UploadInfo.from_path(self.path_or_fileobj)
+        elif isinstance(self.path_or_fileobj, bytes):
+            self.upload_info = UploadInfo.from_bytes(self.path_or_fileobj)
+        else:
+            self.upload_info = UploadInfo.from_fileobj(self.path_or_fileobj)
+
+    @contextmanager
+    def as_file(self, with_tqdm: bool = False) -> Iterator[BinaryIO]:
+        """
+        A context manager that yields a file-like object allowing to read the underlying
+        data behind `path_or_fileobj`.
+
+        Args:
+            with_tqdm (`bool`, *optional*, defaults to `False`):
+                If True, iterating over the file object will display a progress bar. Only
+                works if the file-like object is a path to a file. Pure bytes and buffers
+                are not supported.
+
+        Example:
+
+        ```python
+        >>> operation = CommitOperationAdd(
+        ...        path_in_repo="remote/dir/weights.h5",
+        ...        path_or_fileobj="./local/weights.h5",
+        ... )
+        CommitOperationAdd(path_in_repo='remote/dir/weights.h5', path_or_fileobj='./local/weights.h5')
+
+        >>> with operation.as_file() as file:
+        ...     content = file.read()
+
+        >>> with operation.as_file(with_tqdm=True) as file:
+        ...     while True:
+        ...         data = file.read(1024)
+        ...         if not data:
+        ...              break
+        config.json: 100%|█████████████████████████| 8.19k/8.19k [00:02<00:00, 3.72kB/s]
+
+        >>> with operation.as_file(with_tqdm=True) as file:
+        ...     httpx.put(..., data=file)
+        config.json: 100%|█████████████████████████| 8.19k/8.19k [00:02<00:00, 3.72kB/s]
+        ```
+        """
+        if isinstance(self.path_or_fileobj, str) or isinstance(self.path_or_fileobj, Path):
+            if with_tqdm:
+                with tqdm_stream_file(self.path_or_fileobj) as file:
+                    yield file
+            else:
+                with open(self.path_or_fileobj, "rb") as file:
+                    yield file
+        elif isinstance(self.path_or_fileobj, bytes):
+            yield io.BytesIO(self.path_or_fileobj)
+        elif isinstance(self.path_or_fileobj, io.BufferedIOBase):
+            prev_pos = self.path_or_fileobj.tell()
+            yield self.path_or_fileobj
+            self.path_or_fileobj.seek(prev_pos, io.SEEK_SET)
+
+    def b64content(self) -> bytes:
+        """
+        The base64-encoded content of `path_or_fileobj`
+
+        Returns: `bytes`
+        """
+        with self.as_file() as file:
+            return base64.b64encode(file.read())
+
+    @property
+    def _local_oid(self) -> str | None:
+        """Return the OID of the local file.
+
+        This OID is then compared to `self._remote_oid` to check if the file has changed compared to the remote one.
+        If the file did not change, we won't upload it again to prevent empty commits.
+
+        For LFS files, the OID corresponds to the SHA256 of the file content (used a LFS ref).
+        For regular files, the OID corresponds to the SHA1 of the file content.
+        Note: this is slightly different to git OID computation since the oid of an LFS file is usually the git-SHA1 of the
+              pointer file content (not the actual file content). However, using the SHA256 is enough to detect changes
+              and more convenient client-side.
+        """
+        if self._upload_mode is None:
+            return None
+        elif self._upload_mode == "lfs":
+            return self.upload_info.sha256.hex()
+        else:
+            # Regular file => compute sha1
+            # => no need to read by chunk since the file is guaranteed to be <=5MB.
+            with self.as_file() as file:
+                return sha.git_hash(file.read())
+
+
+def _validate_path_in_repo(path_in_repo: str) -> str:
+    # Validate `path_in_repo` value to prevent a server-side issue
+    if path_in_repo.startswith("/"):
+        path_in_repo = path_in_repo[1:]
+    if path_in_repo == "." or path_in_repo == ".." or path_in_repo.startswith("../"):
+        raise ValueError(f"Invalid `path_in_repo` in CommitOperation: '{path_in_repo}'")
+    if path_in_repo.startswith("./"):
+        path_in_repo = path_in_repo[2:]
+    for forbidden in FORBIDDEN_FOLDERS:
+        if any(part == forbidden for part in path_in_repo.split("/")):
+            raise ValueError(
+                f"Invalid `path_in_repo` in CommitOperation: cannot update files under a '{forbidden}/' folder (path:"
+                f" '{path_in_repo}')."
+            )
+    return path_in_repo
+
+
+CommitOperation = Union[CommitOperationAdd, CommitOperationCopy, CommitOperationDelete]
+
+
+def _warn_on_overwriting_operations(operations: list[CommitOperation]) -> None:
+    """
+    Warn user when a list of operations is expected to overwrite itself in a single
+    commit.
+
+    Rules:
+    - If a filepath is updated by multiple `CommitOperationAdd` operations, a warning
+      message is triggered.
+    - If a filepath is updated at least once by a `CommitOperationAdd` and then deleted
+      by a `CommitOperationDelete`, a warning is triggered.
+    - If a `CommitOperationDelete` deletes a filepath that is then updated by a
+      `CommitOperationAdd`, no warning is triggered. This is usually useless (no need to
+      delete before upload) but can happen if a user deletes an entire folder and then
+      add new files to it.
+    """
+    nb_additions_per_path: dict[str, int] = defaultdict(int)
+    for operation in operations:
+        path_in_repo = operation.path_in_repo
+        if isinstance(operation, CommitOperationAdd):
+            if nb_additions_per_path[path_in_repo] > 0:
+                warnings.warn(
+                    "About to update multiple times the same file in the same commit:"
+                    f" '{path_in_repo}'. This can cause undesired inconsistencies in"
+                    " your repo."
+                )
+            nb_additions_per_path[path_in_repo] += 1
+            for parent in PurePosixPath(path_in_repo).parents:
+                # Also keep track of number of updated files per folder
+                # => warns if deleting a folder overwrite some contained files
+                nb_additions_per_path[str(parent)] += 1
+        if isinstance(operation, CommitOperationDelete):
+            if nb_additions_per_path[str(PurePosixPath(path_in_repo))] > 0:
+                if operation.is_folder:
+                    warnings.warn(
+                        "About to delete a folder containing files that have just been"
+                        f" updated within the same commit: '{path_in_repo}'. This can"
+                        " cause undesired inconsistencies in your repo."
+                    )
+                else:
+                    warnings.warn(
+                        "About to delete a file that have just been updated within the"
+                        f" same commit: '{path_in_repo}'. This can cause undesired"
+                        " inconsistencies in your repo."
+                    )
+
+
+@validate_hf_hub_args
+def _upload_files(
+    *,
+    additions: list[CommitOperationAdd],
+    repo_type: str,
+    repo_id: str,
+    headers: dict[str, str],
+    endpoint: str | None = None,
+    num_threads: int = 5,
+    revision: str | None = None,
+    create_pr: bool | None = None,
+):
+    """
+    Uploads the files through the Xet protocol if possible, otherwise through the legacy LFS protocol.
+
+    The Xet path does not require any Python-side sha256 computation: hashing happens inside `hf_xet`
+    while chunking the files (single read pass) and is backfilled on the operations afterwards.
+    """
+    has_buffered_io_data = any(isinstance(op.path_or_fileobj, io.BufferedIOBase) for op in additions)
+    if is_xet_available():
+        if not has_buffered_io_data:
+            _upload_xet_files(
+                additions=additions,
+                repo_type=repo_type,
+                repo_id=repo_id,
+                headers=headers,
+                endpoint=endpoint,
+                revision=revision,
+                create_pr=create_pr,
+            )
+            return
+        logger.warning(
+            "Uploading files as a binary IO buffer is not supported by Xet Storage. Falling back to HTTP upload."
+        )
+
+    # Legacy LFS path: sha256 is required by the LFS batch endpoint => compute missing ones (in parallel).
+    _compute_missing_sha256s(additions, num_threads=num_threads)
+
+    lfs_actions: list[dict[str, Any]] = []
+    lfs_oid2addop: dict[str, CommitOperationAdd] = {}
+    for chunk in chunk_iterable(additions, chunk_size=UPLOAD_BATCH_MAX_NUM_FILES):
+        chunk_list = [op for op in chunk]
+        actions_chunk, errors_chunk, _ = post_lfs_batch_info(
+            upload_infos=[op.upload_info for op in chunk_list],
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=revision,
+            endpoint=endpoint,
+            headers=headers,
+            token=None,  # already passed in 'headers'
+            transfers=["basic", "multipart"],
+        )
+        if errors_chunk:
+            message = "\n".join(
+                [
+                    f"Encountered error for file with OID {err.get('oid')}: `{err.get('error', {}).get('message')}"
+                    for err in errors_chunk
+                ]
+            )
+            raise ValueError(f"LFS batch API returned errors:\n{message}")
+        lfs_actions.extend(actions_chunk)
+        for op in chunk_list:
+            lfs_oid2addop[op.upload_info.sha256.hex()] = op
+
+    if len(lfs_actions) > 0:
+        _upload_lfs_files(
+            actions=lfs_actions,
+            oid2addop=lfs_oid2addop,
+            headers=headers,
+            endpoint=endpoint,
+            num_threads=num_threads,
+        )
+
+
+def _compute_missing_sha256s(additions: list[CommitOperationAdd], num_threads: int) -> None:
+    """Compute the sha256 of the operations that don't have one yet, in parallel."""
+    not_hashed = [op for op in additions if not op.upload_info.is_hashed]
+    if len(not_hashed) == 0:
+        return
+    logger.info(f"Computing sha256 for {len(not_hashed)} files.")
+    if len(not_hashed) == 1:
+        _ = not_hashed[0].upload_info.sha256
+        return
+    with ThreadPoolExecutor(max_workers=num_threads) as executor:
+        list(executor.map(lambda op: op.upload_info.sha256, not_hashed))
+
+
+@validate_hf_hub_args
+def _upload_lfs_files(
+    *,
+    actions: list[dict[str, Any]],
+    oid2addop: dict[str, CommitOperationAdd],
+    headers: dict[str, str],
+    endpoint: str | None = None,
+    num_threads: int = 5,
+):
+    """
+    Uploads the content of `additions` to the Hub using the large file storage protocol.
+
+    Relevant external documentation:
+        - LFS Batch API: https://github.com/git-lfs/git-lfs/blob/main/docs/api/batch.md
+
+    Args:
+        actions (`list[dict[str, Any]]`):
+            LFS batch actions returned by the server.
+        oid2addop (`dict[str, CommitOperationAdd]`):
+            A dictionary mapping the OID of the file to the corresponding `CommitOperationAdd` object.
+        headers (`dict[str, str]`):
+            Headers to use for the request, including authorization headers and user agent.
+        endpoint (`str`, *optional*):
+            The endpoint to use for the request. Defaults to `constants.ENDPOINT`.
+        num_threads (`int`, *optional*):
+            The number of concurrent threads to use when uploading. Defaults to 5.
+
+    Raises:
+        [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+            If an upload failed for any reason
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            Type of the repo to upload to: `"model"`, `"dataset"` or `"space"`.
+        repo_id (`str`):
+            A namespace (user or an organization) and a repo name separated
+            by a `/`.
+        headers (`dict[str, str]`):
+            Headers to use for the request, including authorization headers and user agent.
+        num_threads (`int`, *optional*):
+            The number of concurrent threads to use when uploading. Defaults to 5.
+        revision (`str`, *optional*):
+            The git revision to upload to.
+
+    Raises:
+        [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+            If an upload failed for any reason
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If the server returns malformed responses
+        [`HfHubHTTPError`]
+            If the LFS batch endpoint returned an HTTP error.
+    """
+    # Filter out files already present upstream
+    filtered_actions = []
+    for action in actions:
+        if action.get("actions") is None:
+            logger.debug(
+                f"Content of file {oid2addop[action['oid']].path_in_repo} is already present upstream - skipping upload."
+            )
+        else:
+            filtered_actions.append(action)
+
+    # Upload according to server-provided actions
+    def _wrapped_lfs_upload(batch_action) -> None:
+        try:
+            operation = oid2addop[batch_action["oid"]]
+            lfs_upload(operation=operation, lfs_batch_action=batch_action, headers=headers, endpoint=endpoint)
+        except Exception as exc:
+            raise RuntimeError(f"Error while uploading '{operation.path_in_repo}' to the Hub.") from exc
+
+    if len(filtered_actions) == 1:
+        logger.debug("Uploading 1 LFS file to the Hub")
+        _wrapped_lfs_upload(filtered_actions[0])
+    else:
+        logger.debug(
+            f"Uploading {len(filtered_actions)} LFS files to the Hub using up to {num_threads} threads concurrently"
+        )
+        thread_map(
+            _wrapped_lfs_upload,
+            filtered_actions,
+            desc=f"Upload {len(filtered_actions)} LFS files",
+            max_workers=num_threads,
+            tqdm_class=hf_tqdm,
+        )
+
+
+@validate_hf_hub_args
+def _upload_xet_files(
+    *,
+    additions: list[CommitOperationAdd],
+    repo_type: str,
+    repo_id: str,
+    headers: dict[str, str],
+    endpoint: str | None = None,
+    revision: str | None = None,
+    create_pr: bool | None = None,
+):
+    """
+    Uploads the content of `additions` to the Hub using the xet storage protocol.
+    This chunks the files and deduplicates the chunks before uploading them to xetcas storage.
+
+    Args:
+        additions (`` of `CommitOperationAdd`):
+            The files to be uploaded.
+        repo_type (`str`):
+            Type of the repo (e.g. `"model"`, `"dataset"`, `"space"`).
+        repo_id (`str`):
+            A namespace (user or an organization) and a repo name separated
+            by a `/`.
+        headers (`dict[str, str]`):
+            Headers to use for the request, including authorization headers and user agent.
+        endpoint: (`str`, *optional*):
+            The endpoint to use for the xetcas service. Defaults to `constants.ENDPOINT`.
+        revision (`str`, *optional*):
+            The git revision to upload to.
+        create_pr (`bool`, *optional*):
+            Whether or not to create a Pull Request with that commit.
+
+    Raises:
+        [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+            If an upload failed for any reason.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If the server returns malformed responses or if the user is unauthorized to upload to xet storage.
+        [`HfHubHTTPError`]
+            If the LFS batch endpoint returned an HTTP error.
+
+    **How it works:**
+        The file upload system uses Xet storage, which is a content-addressable storage system that breaks files into chunks
+        for efficient storage and transfer.
+
+        ``session.new_upload_commit()`` manages uploading files by:
+            - Registering upload tasks and starting upload immediately in the background
+            - Breaking files into smaller chunks for efficient storage
+            - Avoiding duplicate storage by recognizing identical chunks across files
+            - Connecting to a storage server (CAS server) that manages these chunks
+
+        Authentication works transparently: the upload commit accepts a ``token_refresh_url``
+        that is used to refresh the short-lived xet write token as needed.
+
+        The upload process works like this:
+        1. Upload tasks run in parallel:
+            1.1. Read the file content from a path, bytes array, or a stream.
+            1.2. Split the file content into smaller chunks based on content patterns: each chunk gets a unique ID based on what's in it.
+            1.3. For each chunk:
+                - Check if it already exists in storage.
+                - Skip uploading chunks that already exist.
+            1.4. Group chunks into larger blocks for efficient transfer.
+            1.5. Upload these blocks to the storage server.
+            1.6. Assemble the file manifest locally and send it to the server for validation.
+        2. Return reference files that contain information about the uploaded files, which can be used later to download them.
+    """
+    if len(additions) == 0:
+        return
+
+    # at this point, we know that hf_xet is installed
+    from .utils._xet import (
+        XetTokenType,
+        abort_xet_session,
+        get_xet_session,
+        xet_connection_info_refresh_url,
+        xet_headers_without_auth,
+    )
+    from .utils._xet_progress_reporting import XetUploadProgressReporter
+
+    refresh_url = xet_connection_info_refresh_url(
+        token_type=XetTokenType.WRITE,
+        repo_id=repo_id,
+        repo_type=repo_type,
+        revision=revision,
+        endpoint=endpoint,
+    )
+    if create_pr:
+        refresh_url += "?create_pr=1"
+
+    xet_headers = xet_headers_without_auth(headers)
+
+    import hf_xet
+
+    session = get_xet_session()
+    progress = None
+
+    def _sha256_arg(op: CommitOperationAdd):
+        # If the sha256 is already known, pass it to avoid recomputation. Otherwise let hf_xet
+        # compute it while chunking the file (single read pass) and backfill it afterwards.
+        return op.upload_info.sha256.hex() if op.upload_info.is_hashed else hf_xet.COMPUTE_SHA256
+
+    try:
+        if not are_progress_bars_disabled():
+            progress = XetUploadProgressReporter()
+            progress_callback = progress.update_progress
+        else:
+            progress_callback = None
+
+        all_bytes_ops = [op for op in additions if isinstance(op.path_or_fileobj, bytes)]
+        all_paths_ops = [op for op in additions if isinstance(op.path_or_fileobj, (str, Path))]
+
+        handles: list[tuple[CommitOperationAdd, Any]] = []
+        with session.new_upload_commit(
+            token_refresh_url=refresh_url,
+            token_refresh_headers=headers,
+            custom_headers=xet_headers,
+            progress_callback=progress_callback,
+        ) as commit:
+            for op in all_paths_ops:
+                handles.append((op, commit.start_upload_file(str(op.path_or_fileobj), sha256=_sha256_arg(op))))
+            for op in all_bytes_ops:
+                handles.append((op, commit.start_upload_bytes(op.path_or_fileobj, sha256=_sha256_arg(op))))
+
+        # Backfill sha256 computed by hf_xet (needed later for the commit payload).
+        for op, handle in handles:
+            if not op.upload_info.is_hashed:
+                op.upload_info.sha256 = bytes.fromhex(handle.result().xet_info.sha256)
+    except KeyboardInterrupt:
+        abort_xet_session()
+        raise
+    finally:
+        if progress is not None:
+            progress.close()
+
+
+def _validate_preupload_info(preupload_info: dict):
+    files = preupload_info.get("files")
+    if not isinstance(files, list):
+        raise ValueError("preupload_info is improperly formatted")
+    for file_info in files:
+        if not (
+            isinstance(file_info, dict)
+            and isinstance(file_info.get("path"), str)
+            and isinstance(file_info.get("uploadMode"), str)
+            and (file_info["uploadMode"] in ("lfs", "regular"))
+        ):
+            raise ValueError("preupload_info is improperly formatted:")
+    return preupload_info
+
+
+@validate_hf_hub_args
+def _fetch_upload_modes(
+    additions: Iterable[CommitOperationAdd],
+    repo_type: str,
+    repo_id: str,
+    headers: dict[str, str],
+    revision: str,
+    endpoint: str | None = None,
+    create_pr: bool = False,
+    gitignore_content: str | None = None,
+) -> None:
+    """
+    Requests the Hub "preupload" endpoint to determine whether each input file should be uploaded as a regular git blob,
+    as a git LFS blob, or as a XET file. Input `additions` are mutated in-place with the upload mode.
+
+    Args:
+        additions (`Iterable` of :class:`CommitOperationAdd`):
+            Iterable of :class:`CommitOperationAdd` describing the files to
+            upload to the Hub.
+        repo_type (`str`):
+            Type of the repo to upload to: `"model"`, `"dataset"` or `"space"`.
+        repo_id (`str`):
+            A namespace (user or an organization) and a repo name separated
+            by a `/`.
+        headers (`dict[str, str]`):
+            Headers to use for the request, including authorization headers and user agent.
+        revision (`str`):
+            The git revision to upload the files to. Can be any valid git revision.
+        gitignore_content (`str`, *optional*):
+            The content of the `.gitignore` file to know which files should be ignored. The order of priority
+            is to first check if `gitignore_content` is passed, then check if the `.gitignore` file is present
+            in the list of files to commit and finally default to the `.gitignore` file already hosted on the Hub
+            (if any).
+    Raises:
+        [`~utils.HfHubHTTPError`]
+            If the Hub API returned an error.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If the Hub API response is improperly formatted.
+    """
+    endpoint = endpoint if endpoint is not None else constants.ENDPOINT
+
+    # Fetch upload mode (LFS or regular) chunk by chunk.
+    upload_modes: dict[str, UploadMode] = {}
+    should_ignore_info: dict[str, bool] = {}
+    oid_info: dict[str, str | None] = {}
+
+    for chunk in chunk_iterable(additions, 256):
+        payload: dict = {
+            "files": [
+                {
+                    "path": op.path_in_repo,
+                    "sample": base64.b64encode(op.upload_info.sample).decode("ascii"),
+                    "size": op.upload_info.size,
+                }
+                for op in chunk
+            ]
+        }
+        if gitignore_content is not None:
+            payload["gitIgnore"] = gitignore_content
+
+        resp = http_backoff(
+            "POST",
+            f"{endpoint}/api/{repo_type}s/{repo_id}/preupload/{revision}",
+            json=payload,
+            headers=headers,
+            params={"create_pr": "1"} if create_pr else None,
+        )
+        hf_raise_for_status(resp)
+        preupload_info = _validate_preupload_info(resp.json())
+        upload_modes.update(**{file["path"]: file["uploadMode"] for file in preupload_info["files"]})
+        should_ignore_info.update(**{file["path"]: file["shouldIgnore"] for file in preupload_info["files"]})
+        oid_info.update(**{file["path"]: file.get("oid") for file in preupload_info["files"]})
+
+    # Set upload mode for each addition operation
+    for addition in additions:
+        addition._upload_mode = upload_modes[addition.path_in_repo]
+        addition._should_ignore = should_ignore_info[addition.path_in_repo]
+        addition._remote_oid = oid_info[addition.path_in_repo]
+
+    # Empty files cannot be uploaded as LFS (S3 would fail with a 501 Not Implemented)
+    # => empty files are uploaded as "regular" to still allow users to commit them.
+    for addition in additions:
+        if addition.upload_info.size == 0:
+            addition._upload_mode = "regular"
+
+
+class _CopySource(NamedTuple):
+    src_repo_id: str | None
+    src_repo_type: str | None
+    path: str
+    revision: str | None
+
+
+@validate_hf_hub_args
+def _fetch_files_to_copy(
+    copies: Iterable[CommitOperationCopy],
+    repo_type: str,
+    repo_id: str,
+    headers: dict[str, str],
+    revision: str,
+    endpoint: str | None = None,
+) -> dict[_CopySource, Union["RepoFile", bytes]]:
+    """
+    Fetch information about the files to copy.
+
+    For LFS files, we only need their metadata (file size and sha256) while for regular files
+    we need to download the raw content from the Hub.
+
+    Args:
+        copies (`Iterable` of :class:`CommitOperationCopy`):
+            Iterable of :class:`CommitOperationCopy` describing the files to
+            copy on the Hub.
+        repo_type (`str`):
+            Type of the repo to upload to: `"model"`, `"dataset"` or `"space"`.
+        repo_id (`str`):
+            A namespace (user or an organization) and a repo name separated
+            by a `/`.
+        headers (`dict[str, str]`):
+            Headers to use for the request, including authorization headers and user agent.
+        revision (`str`):
+            The git revision to upload the files to. Can be any valid git revision.
+
+    Returns: `dict[_CopySource, Union[RepoFile, bytes]]]`
+        Key is `(src_repo_id, src_repo_type, path, revision)`. For intra-repo copies,
+        `src_repo_id` and `src_repo_type` are `None`.
+        Value is the raw content as bytes (for regular files) or the file information as a RepoFile (for LFS files).
+
+    Raises:
+        [`~utils.HfHubHTTPError`]
+            If the Hub API returned an error.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If the Hub API response is improperly formatted.
+    """
+    from .hf_api import HfApi, RepoFolder
+
+    hf_api = HfApi(endpoint=endpoint, headers=headers)
+    copies = list(copies)
+    files_to_copy: dict[_CopySource, Union["RepoFile", bytes]] = {}
+    oid_info: dict[tuple[str, str | None], str | None] = {}
+
+    # 1. Fetch OIDs for destination paths in batches.
+    dest_paths = [op.path_in_repo for op in copies]
+    for batch in chunk_iterable(dest_paths, FETCH_LFS_BATCH_SIZE):
+        dest_repo_files = hf_api.get_paths_info(
+            repo_id=repo_id,
+            paths=list(batch),
+            revision=revision,
+            repo_type=repo_type,
+        )
+        for file in dest_repo_files:
+            if not isinstance(file, RepoFolder):
+                oid_info[(file.path, revision)] = file.blob_id
+
+    # 2. Fetch source file info, grouped by (src_repo_id, src_repo_type, src_revision).
+    copies.sort(key=lambda op: (op.src_repo_id or "", op.src_repo_type or "", op.src_revision or ""))
+    for (src_repo_id_key, src_repo_type_key, src_revision_key), group in groupby(
+        copies, key=lambda op: (op.src_repo_id, op.src_repo_type, op.src_revision)
+    ):
+        operations = list(group)
+        is_cross_repo = src_repo_id_key is not None
+        eff_repo_id = src_repo_id_key or repo_id
+        eff_repo_type = src_repo_type_key or repo_type
+        eff_revision = src_revision_key or ("main" if is_cross_repo else revision)
+
+        src_paths = [op.src_path_in_repo for op in operations]
+        for paths_batch in chunk_iterable(src_paths, FETCH_LFS_BATCH_SIZE):
+            src_repo_files = hf_api.get_paths_info(
+                repo_id=eff_repo_id,
+                paths=list(paths_batch),
+                revision=eff_revision,
+                repo_type=eff_repo_type,
+            )
+            for src_repo_file in src_repo_files:
+                if isinstance(src_repo_file, RepoFolder):
+                    raise NotImplementedError("Copying a folder is not implemented.")
+                source = _CopySource(src_repo_id_key, src_repo_type_key, src_repo_file.path, src_revision_key)
+                if src_repo_file.lfs:
+                    files_to_copy[source] = src_repo_file
+                else:
+                    url = hf_hub_url(
+                        endpoint=endpoint,
+                        repo_type=eff_repo_type,
+                        repo_id=eff_repo_id,
+                        revision=eff_revision,
+                        filename=src_repo_file.path,
+                    )
+                    response = get_session().get(url, headers=headers)
+                    hf_raise_for_status(response)
+                    files_to_copy[source] = response.content
+                if not is_cross_repo:
+                    oid_info[(src_repo_file.path, src_revision_key)] = src_repo_file.blob_id
+
+        for operation in operations:
+            key = _CopySource(src_repo_id_key, src_repo_type_key, operation.src_path_in_repo, src_revision_key)
+            if key not in files_to_copy:
+                source_desc = f" from {eff_repo_type}s/{eff_repo_id}" if is_cross_repo else ""
+                raise EntryNotFoundError(
+                    f"Cannot copy {operation.src_path_in_repo} at revision "
+                    f"{eff_revision}{source_desc}: file is missing on repo."
+                )
+            operation._dest_oid = oid_info.get((operation.path_in_repo, revision))
+            if not is_cross_repo:
+                operation._src_oid = oid_info.get((operation.src_path_in_repo, operation.src_revision))
+
+    return files_to_copy
+
+
+def _prepare_commit_payload(
+    operations: Iterable[CommitOperation],
+    files_to_copy: dict[_CopySource, Union["RepoFile", bytes]],
+    commit_message: str,
+    commit_description: str | None = None,
+    parent_commit: str | None = None,
+) -> Iterable[dict[str, Any]]:
+    """
+    Builds the payload to POST to the `/commit` API of the Hub.
+
+    Payload is returned as an iterator so that it can be streamed as a ndjson in the
+    POST request.
+
+    For more information, see:
+        - https://github.com/huggingface/huggingface_hub/issues/1085#issuecomment-1265208073
+        - http://ndjson.org/
+    """
+    commit_description = commit_description if commit_description is not None else ""
+
+    # 1. Send a header item with the commit metadata
+    header_value = {"summary": commit_message, "description": commit_description}
+    if parent_commit is not None:
+        header_value["parentCommit"] = parent_commit
+    yield {"key": "header", "value": header_value}
+
+    nb_ignored_files = 0
+
+    # 2. Send operations, one per line
+    for operation in operations:
+        # Skip ignored files
+        if isinstance(operation, CommitOperationAdd) and operation._should_ignore:
+            logger.debug(f"Skipping file '{operation.path_in_repo}' in commit (ignored by gitignore file).")
+            nb_ignored_files += 1
+            continue
+
+        # 2.a. Case adding a regular file
+        if isinstance(operation, CommitOperationAdd) and operation._upload_mode == "regular":
+            yield {
+                "key": "file",
+                "value": {
+                    "content": operation.b64content().decode(),
+                    "path": operation.path_in_repo,
+                    "encoding": "base64",
+                },
+            }
+        # 2.b. Case adding an LFS file
+        elif isinstance(operation, CommitOperationAdd) and operation._upload_mode == "lfs":
+            yield {
+                "key": "lfsFile",
+                "value": {
+                    "path": operation.path_in_repo,
+                    "algo": "sha256",
+                    "oid": operation.upload_info.sha256.hex(),
+                    "size": operation.upload_info.size,
+                },
+            }
+        # 2.c. Case deleting a file or folder
+        elif isinstance(operation, CommitOperationDelete):
+            yield {
+                "key": "deletedFolder" if operation.is_folder else "deletedFile",
+                "value": {"path": operation.path_in_repo},
+            }
+        # 2.d. Case copying a file or folder
+        elif isinstance(operation, CommitOperationCopy):
+            source = _CopySource(
+                operation.src_repo_id,
+                operation.src_repo_type,
+                operation.src_path_in_repo,
+                operation.src_revision,
+            )
+            file_to_copy = files_to_copy[source]
+            if isinstance(file_to_copy, bytes):
+                yield {
+                    "key": "file",
+                    "value": {
+                        "content": base64.b64encode(file_to_copy).decode(),
+                        "path": operation.path_in_repo,
+                        "encoding": "base64",
+                    },
+                }
+            elif file_to_copy.lfs:
+                yield {
+                    "key": "lfsFile",
+                    "value": {
+                        "path": operation.path_in_repo,
+                        "algo": "sha256",
+                        "oid": file_to_copy.lfs.sha256,
+                    },
+                }
+            else:
+                raise ValueError(
+                    "Malformed files_to_copy (should be raw file content as bytes or RepoFile objects with LFS info."
+                )
+        # 2.e. Never expected to happen
+        else:
+            raise ValueError(
+                f"Unknown operation to commit. Operation: {operation}. Upload mode:"
+                f" {getattr(operation, '_upload_mode', None)}"
+            )
+
+    if nb_ignored_files > 0:
+        logger.info(f"Skipped {nb_ignored_files} file(s) in commit (ignored by gitignore file).")
+
+
+def _send_commit(
+    *,
+    operations: Iterable[CommitOperation],
+    files_to_copy: dict[_CopySource, Union["RepoFile", bytes]],
+    commit_message: str,
+    commit_description: str,
+    repo_type: str,
+    repo_id: str,
+    headers: dict[str, str],
+    revision: str,
+    endpoint: str | None = None,
+    parent_commit: str | None = None,
+    create_pr: bool = False,
+    hot_reload: bool = False,
+    retry_on_error: bool = False,
+) -> "CommitInfo":
+    """
+    Build the ndjson payload for `operations` and POST it to the `/commit` endpoint of the Hub.
+
+    `revision` must already be URL-quoted. Operations must be ready to commit: upload modes fetched
+    and LFS/Xet content uploaded.
+
+    If `retry_on_error` is `True`, the POST is retried with exponential backoff on transient errors.
+    Caution: if a commit succeeds but its response is lost, the retry will create a duplicate commit
+    (and a duplicate pull request if `create_pr` is set) — only enable it when this is acceptable.
+
+    Returns a [`CommitInfo`] built from the server response.
+
+    Raises:
+        [`~utils.HfHubHTTPError`]
+            If the Hub API returned an error.
+    """
+    endpoint = endpoint if endpoint is not None else constants.ENDPOINT
+    payload = _prepare_commit_payload(
+        operations=operations,
+        files_to_copy=files_to_copy,
+        commit_message=commit_message,
+        commit_description=commit_description,
+        parent_commit=parent_commit,
+    )
+    data = b"".join(json.dumps(item).encode() + b"\n" for item in payload)
+    # See https://github.com/huggingface/huggingface_hub/issues/1085#issuecomment-1265208073
+    headers = {"Content-Type": "application/x-ndjson", **headers}
+    url = f"{endpoint}/api/{repo_type}s/{repo_id}/commit/{revision}"
+
+    params: dict[str, str] = {}
+    if create_pr:
+        params["create_pr"] = "1"
+    if hot_reload:
+        params["hot_reload"] = "1"
+
+    if retry_on_error:
+        response = http_backoff("POST", url, headers=headers, content=data, params=params)
+    else:
+        response = get_session().post(url, headers=headers, content=data, params=params)
+    hf_raise_for_status(response, endpoint_name="commit")
+
+    commit_data = response.json()
+    from .hf_api import CommitInfo
+
+    return CommitInfo(
+        commit_url=commit_data["commitUrl"],
+        commit_message=commit_message,
+        commit_description=commit_description,
+        oid=commit_data["commitOid"],
+        pr_url=commit_data["pullRequestUrl"] if create_pr else None,
+        _endpoint=endpoint,
+    )

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_commit_scheduler.py

@@ -0,0 +1,353 @@
+import atexit
+import logging
+import os
+import time
+from concurrent.futures import Future
+from dataclasses import dataclass
+from io import SEEK_END, SEEK_SET, BytesIO
+from pathlib import Path
+from threading import Lock, Thread
+from typing import Optional
+
+from .hf_api import DEFAULT_IGNORE_PATTERNS, CommitInfo, CommitOperationAdd, HfApi
+from .utils import filter_repo_objects
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class _FileToUpload:
+    """Temporary dataclass to store info about files to upload. Not meant to be used directly."""
+
+    local_path: Path
+    path_in_repo: str
+    size_limit: int
+    last_modified: float
+
+
+class CommitScheduler:
+    """
+    Scheduler to upload a local folder to the Hub at regular intervals (e.g. push to hub every 5 minutes).
+
+    The recommended way to use the scheduler is to use it as a context manager. This ensures that the scheduler is
+    properly stopped and the last commit is triggered when the script ends. The scheduler can also be stopped manually
+    with the `stop` method. Checkout the [upload guide](https://huggingface.co/docs/huggingface_hub/guides/upload#scheduled-uploads)
+    to learn more about how to use it.
+
+    Args:
+        repo_id (`str`):
+            The id of the repo to commit to.
+        folder_path (`str` or `Path`):
+            Path to the local folder to upload regularly.
+        every (`int` or `float`, *optional*):
+            The number of minutes between each commit. Defaults to 5 minutes.
+        path_in_repo (`str`, *optional*):
+            Relative path of the directory in the repo, for example: `"checkpoints/"`. Defaults to the root folder
+            of the repository.
+        repo_type (`str`, *optional*):
+            The type of the repo to commit to. Defaults to `model`.
+        revision (`str`, *optional*):
+            The revision of the repo to commit to. Defaults to `main`.
+        private (`bool`, *optional*):
+            Whether to make the repo private. If `None` (default), the repo will be public unless the organization's default is private. This value is ignored if the repo already exists.
+        token (`str`, *optional*):
+            The token to use to commit to the repo. Defaults to the token saved on the machine.
+        allow_patterns (`list[str]` or `str`, *optional*):
+            If provided, only files matching at least one pattern are uploaded.
+        ignore_patterns (`list[str]` or `str`, *optional*):
+            If provided, files matching any of the patterns are not uploaded.
+        squash_history (`bool`, *optional*):
+            Whether to squash the history of the repo after each commit. Defaults to `False`. Squashing commits is
+            useful to avoid degraded performances on the repo when it grows too large.
+        hf_api (`HfApi`, *optional*):
+            The [`HfApi`] client to use to commit to the Hub. Can be set with custom settings (user agent, token,...).
+
+    Example:
+    ```py
+    >>> from pathlib import Path
+    >>> from huggingface_hub import CommitScheduler
+
+    # Scheduler uploads every 10 minutes
+    >>> csv_path = Path("watched_folder/data.csv")
+    >>> CommitScheduler(repo_id="test_scheduler", repo_type="dataset", folder_path=csv_path.parent, every=10)
+
+    >>> with csv_path.open("a") as f:
+    ...     f.write("first line")
+
+    # Some time later (...)
+    >>> with csv_path.open("a") as f:
+    ...     f.write("second line")
+    ```
+
+    Example using a context manager:
+    ```py
+    >>> from pathlib import Path
+    >>> from huggingface_hub import CommitScheduler
+
+    >>> with CommitScheduler(repo_id="test_scheduler", repo_type="dataset", folder_path="watched_folder", every=10) as scheduler:
+    ...     csv_path = Path("watched_folder/data.csv")
+    ...     with csv_path.open("a") as f:
+    ...         f.write("first line")
+    ...     (...)
+    ...     with csv_path.open("a") as f:
+    ...         f.write("second line")
+
+    # Scheduler is now stopped and last commit have been triggered
+    ```
+    """
+
+    def __init__(
+        self,
+        *,
+        repo_id: str,
+        folder_path: str | Path,
+        every: int | float = 5,
+        path_in_repo: str | None = None,
+        repo_type: str | None = None,
+        revision: str | None = None,
+        private: bool | None = None,
+        token: str | None = None,
+        allow_patterns: list[str] | str | None = None,
+        ignore_patterns: list[str] | str | None = None,
+        squash_history: bool = False,
+        hf_api: Optional["HfApi"] = None,
+    ) -> None:
+        self.api = hf_api or HfApi(token=token)
+
+        # Folder
+        self.folder_path = Path(folder_path).expanduser().resolve()
+        self.path_in_repo = path_in_repo or ""
+        self.allow_patterns = allow_patterns
+
+        if ignore_patterns is None:
+            ignore_patterns = []
+        elif isinstance(ignore_patterns, str):
+            ignore_patterns = [ignore_patterns]
+        self.ignore_patterns = ignore_patterns + DEFAULT_IGNORE_PATTERNS
+
+        if self.folder_path.is_file():
+            raise ValueError(f"'folder_path' must be a directory, not a file: '{self.folder_path}'.")
+        self.folder_path.mkdir(parents=True, exist_ok=True)
+
+        # Repository
+        repo_url = self.api.create_repo(repo_id=repo_id, private=private, repo_type=repo_type, exist_ok=True)
+        self.repo_id = repo_url.repo_id
+        self.repo_type = repo_type
+        self.revision = revision
+        self.token = token
+
+        # Keep track of already uploaded files
+        self.last_uploaded: dict[Path, float] = {}  # key is local path, value is timestamp
+
+        # Scheduler
+        if not every > 0:
+            raise ValueError(f"'every' must be a positive integer, not '{every}'.")
+        self.lock = Lock()
+        self.every = every
+        self.squash_history = squash_history
+
+        logger.info(f"Scheduled job to push '{self.folder_path}' to '{self.repo_id}' every {self.every} minutes.")
+        self._scheduler_thread = Thread(target=self._run_scheduler, daemon=True)
+        self._scheduler_thread.start()
+        atexit.register(self._push_to_hub)
+
+        self.__stopped = False
+
+    def stop(self) -> None:
+        """Stop the scheduler.
+
+        A stopped scheduler cannot be restarted. Mostly for tests purposes.
+        """
+        self.__stopped = True
+
+    def __enter__(self) -> "CommitScheduler":
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        # Upload last changes before exiting
+        self.trigger().result()
+        self.stop()
+        return
+
+    def _run_scheduler(self) -> None:
+        """Dumb thread waiting between each scheduled push to Hub."""
+        while True:
+            self.last_future = self.trigger()
+            time.sleep(self.every * 60)
+            if self.__stopped:
+                break
+
+    def trigger(self) -> Future:
+        """Trigger a `push_to_hub` and return a future.
+
+        This method is automatically called every `every` minutes. You can also call it manually to trigger a commit
+        immediately, without waiting for the next scheduled commit.
+        """
+        return self.api.run_as_future(self._push_to_hub)
+
+    def _push_to_hub(self) -> CommitInfo | None:
+        if self.__stopped:  # If stopped, already scheduled commits are ignored
+            return None
+
+        logger.info("(Background) scheduled commit triggered.")
+        try:
+            value = self.push_to_hub()
+            if self.squash_history:
+                logger.info("(Background) squashing repo history.")
+                self.api.super_squash_history(repo_id=self.repo_id, repo_type=self.repo_type, branch=self.revision)
+            return value
+        except Exception as e:
+            logger.error(f"Error while pushing to Hub: {e}")  # Depending on the setup, error might be silenced
+            raise
+
+    def push_to_hub(self) -> CommitInfo | None:
+        """
+        Push folder to the Hub and return the commit info.
+
+        > [!WARNING]
+        > This method is not meant to be called directly. It is run in the background by the scheduler, respecting a
+        > queue mechanism to avoid concurrent commits. Making a direct call to the method might lead to concurrency
+        > issues.
+
+        The default behavior of `push_to_hub` is to assume an append-only folder. It lists all files in the folder and
+        uploads only changed files. If no changes are found, the method returns without committing anything. If you want
+        to change this behavior, you can inherit from [`CommitScheduler`] and override this method. This can be useful
+        for example to compress data together in a single file before committing. For more details and examples, check
+        out our [integration guide](https://huggingface.co/docs/huggingface_hub/main/en/guides/upload#scheduled-uploads).
+        """
+        # Check files to upload (with lock)
+        with self.lock:
+            logger.debug("Listing files to upload for scheduled commit.")
+
+            # List files from folder (taken from `_prepare_upload_folder_additions`)
+            relpath_to_abspath = {
+                path.relative_to(self.folder_path).as_posix(): path
+                for path in sorted(self.folder_path.glob("**/*"))  # sorted to be deterministic
+                if path.is_file()
+            }
+            prefix = f"{self.path_in_repo.strip('/')}/" if self.path_in_repo else ""
+
+            # Filter with pattern + filter out unchanged files + retrieve current file size
+            files_to_upload: list[_FileToUpload] = []
+            for relpath in filter_repo_objects(
+                relpath_to_abspath.keys(), allow_patterns=self.allow_patterns, ignore_patterns=self.ignore_patterns
+            ):
+                local_path = relpath_to_abspath[relpath]
+                stat = local_path.stat()
+                if self.last_uploaded.get(local_path) is None or self.last_uploaded[local_path] != stat.st_mtime:
+                    files_to_upload.append(
+                        _FileToUpload(
+                            local_path=local_path,
+                            path_in_repo=prefix + relpath,
+                            size_limit=stat.st_size,
+                            last_modified=stat.st_mtime,
+                        )
+                    )
+
+        # Return if nothing to upload
+        if len(files_to_upload) == 0:
+            logger.debug("Dropping schedule commit: no changed file to upload.")
+            return None
+
+        # Convert `_FileToUpload` as `CommitOperationAdd` (=> compute file shas + limit to file size)
+        logger.debug("Removing unchanged files since previous scheduled commit.")
+        add_operations = [
+            CommitOperationAdd(
+                # Cap the file to its current size, even if the user append data to it while a scheduled commit is happening
+                path_or_fileobj=PartialFileIO(file_to_upload.local_path, size_limit=file_to_upload.size_limit),
+                path_in_repo=file_to_upload.path_in_repo,
+            )
+            for file_to_upload in files_to_upload
+        ]
+
+        # Upload files (append mode expected - no need for lock)
+        logger.debug("Uploading files for scheduled commit.")
+        commit_info = self.api.create_commit(
+            repo_id=self.repo_id,
+            repo_type=self.repo_type,
+            operations=add_operations,
+            commit_message="Scheduled Commit",
+            revision=self.revision,
+        )
+
+        # Successful commit: keep track of the latest "last_modified" for each file
+        for file in files_to_upload:
+            self.last_uploaded[file.local_path] = file.last_modified
+        return commit_info
+
+
+class PartialFileIO(BytesIO):
+    """A file-like object that reads only the first part of a file.
+
+    Useful to upload a file to the Hub when the user might still be appending data to it. Only the first part of the
+    file is uploaded (i.e. the part that was available when the filesystem was first scanned).
+
+    In practice, only used internally by the CommitScheduler to regularly push a folder to the Hub with minimal
+    disturbance for the user. The object is passed to `CommitOperationAdd`.
+
+    Only supports `read`, `tell` and `seek` methods.
+
+    Args:
+        file_path (`str` or `Path`):
+            Path to the file to read.
+        size_limit (`int`):
+            The maximum number of bytes to read from the file. If the file is larger than this, only the first part
+            will be read (and uploaded).
+    """
+
+    def __init__(self, file_path: str | Path, size_limit: int) -> None:
+        self._file_path = Path(file_path)
+        self._file = self._file_path.open("rb")
+        self._size_limit = min(size_limit, os.fstat(self._file.fileno()).st_size)
+
+    def __del__(self) -> None:
+        self._file.close()
+        return super().__del__()
+
+    def __repr__(self) -> str:
+        return f"<PartialFileIO file_path={self._file_path} size_limit={self._size_limit}>"
+
+    def __len__(self) -> int:
+        return self._size_limit
+
+    def __getattribute__(self, name: str):
+        if name.startswith("_") or name in ("read", "tell", "seek", "fileno"):  # only 4 public methods supported
+            return super().__getattribute__(name)
+        raise NotImplementedError(f"PartialFileIO does not support '{name}'.")
+
+    def fileno(self):
+        raise AttributeError("PartialFileIO does not have a fileno.")
+
+    def tell(self) -> int:
+        """Return the current file position."""
+        return self._file.tell()
+
+    def seek(self, __offset: int, __whence: int = SEEK_SET) -> int:
+        """Change the stream position to the given offset.
+
+        Behavior is the same as a regular file, except that the position is capped to the size limit.
+        """
+        if __whence == SEEK_END:
+            # SEEK_END => set from the truncated end
+            __offset = len(self) + __offset
+            __whence = SEEK_SET
+
+        pos = self._file.seek(__offset, __whence)
+        if pos > self._size_limit:
+            return self._file.seek(self._size_limit)
+        return pos
+
+    def read(self, __size: int | None = -1) -> bytes:
+        """Read at most `__size` bytes from the file.
+
+        Behavior is the same as a regular file, except that it is capped to the size limit.
+        """
+        current = self._file.tell()
+        if __size is None or __size < 0:
+            # Read until file limit
+            truncated_size = self._size_limit - current
+        else:
+            # Read until file limit or __size
+            truncated_size = min(__size, self._size_limit - current)
+        return self._file.read(truncated_size)

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_dataset_viewer.py

@@ -0,0 +1,172 @@
+# 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 os
+import shutil
+import subprocess
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Union
+
+from . import constants
+from .utils import get_token
+
+
+if TYPE_CHECKING:
+    import duckdb
+
+
+@dataclass(frozen=True)
+class DatasetParquetEntry:
+    """Represents a single parquet file available for a dataset on the Hub."""
+
+    config: str
+    split: str
+    url: str
+    size: int
+
+
+def execute_raw_sql_query(sql_query: str, *, token: str | bool | None = None) -> list[dict[str, Any]]:
+    normalized_query = sql_query.strip().rstrip(";").strip()
+    _raise_on_forbidden_query(normalized_query)
+
+    connection = None
+    try:
+        connection = _get_duckdb_connection(token=token)
+        relation = connection.sql(normalized_query)
+        if relation is None:
+            raise ValueError("SQL query must return rows.")
+
+        if isinstance(relation, _DuckDBCliRelation):
+            # DuckDB binary => run CLI => parse JSON
+            return relation.execute()
+        else:
+            # DuckDB Python API => fetch columns + rows => convert to dicts
+            columns = tuple(column[0] for column in relation.description)
+            rows = tuple(tuple(row) for row in relation.fetchall())
+            return [dict(zip(columns, row)) for row in rows]
+    finally:
+        if connection is not None:
+            connection.close()
+
+
+def _raise_on_forbidden_query(query: str) -> None:
+    if len(query) == 0:
+        raise ValueError("SQL query cannot be empty.")
+
+    # DuckDB CLI meta-commands are dot-prefixed words (e.g. `.shell`, `.output`).
+    # Let's forbid them for now but allow SQL expressions like `.5` that can legitimately start a line.
+    for line in query.splitlines():
+        stripped = line.lstrip()
+        if stripped.startswith(".") and stripped[1:2].isalpha():
+            raise ValueError("DuckDB CLI meta-commands are not allowed in SQL queries.")
+
+
+def _get_duckdb_connection(
+    token: str | bool | None,
+) -> Union["duckdb.DuckDBPyConnection", "_DuckDBCliConnection"]:
+    try:
+        # If DuckDB is installed as a Python package, use it!
+        import duckdb
+    except ImportError as error:
+        # Otherwise, use the DuckDB CLI binary.
+        duckdb_binary = shutil.which("duckdb")
+        if duckdb_binary is None:
+            raise ImportError(
+                "DuckDB is required for `hf datasets sql`. Install the Python package with `pip install duckdb` or "
+                "install the DuckDB CLI binary (for example `brew install duckdb`)."
+            ) from error
+        return _DuckDBCliConnection(binary_path=duckdb_binary, token=token)
+
+    # Create a new connection (Python API).
+    connection = duckdb.connect()
+    try:
+        for statement in _build_duckdb_secret_statements(token):
+            connection.execute(statement)
+        return connection
+    except Exception:
+        connection.close()
+        raise
+
+
+@dataclass
+class _DuckDBCliConnection:
+    """DuckDB connection.
+
+    Mimics the DuckDB Python API, but runs the queries via the DuckDB CLI binary.
+    """
+
+    binary_path: str
+    token: str | bool | None
+
+    def __post_init__(self) -> None:
+        self._setup_statements = _build_duckdb_secret_statements(self.token)
+
+    def sql(self, query: str) -> "_DuckDBCliRelation":
+        return _DuckDBCliRelation(binary_path=self.binary_path, setup_statements=self._setup_statements, query=query)
+
+    def close(self) -> None:
+        pass
+
+
+@dataclass
+class _DuckDBCliRelation:
+    """DuckDB relation.
+
+    Mimics the DuckDB Python API, but runs the queries via the DuckDB CLI binary.
+    """
+
+    binary_path: str
+    setup_statements: list[str]
+    query: str
+
+    def execute(self) -> list[dict[str, Any]]:
+        # Build the DuckDB CLI input.
+        setup = []
+        if self.setup_statements:
+            setup = [
+                f".output {os.devnull}",
+                *(f"{stmt};" for stmt in self.setup_statements),
+                ".output",
+            ]
+        full_query = "\n".join(setup + [self.query + ";"])
+
+        # Run DuckDB binary
+        result = subprocess.run(
+            [self.binary_path, "-json"],
+            input=full_query,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            error_message = result.stderr.strip() or result.stdout.strip() or "DuckDB CLI command failed."
+            raise RuntimeError(error_message)
+
+        # Parse JSON output and return
+        return json.loads(result.stdout.strip())
+
+
+def _build_duckdb_secret_statements(token: str | bool | None) -> list[str]:
+    if token is None or token is True:
+        token = get_token()
+
+    if not token:
+        return []
+
+    escaped_token = token.replace("'", "''")
+    escaped_endpoint = constants.ENDPOINT.replace("'", "''")
+    return [
+        f"CREATE OR REPLACE SECRET hf_hub_token (TYPE HTTP, BEARER_TOKEN '{escaped_token}', SCOPE '{escaped_endpoint}')",
+        f"CREATE OR REPLACE SECRET hf_token (TYPE HUGGINGFACE, TOKEN '{escaped_token}')",
+    ]

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_eval_results.py

@@ -0,0 +1,211 @@
+"""Evaluation results utilities for the `.eval_results/*.yaml` format.
+
+See https://huggingface.co/docs/hub/eval-results for more details.
+Specifications are available at https://github.com/huggingface/hub-docs/blob/main/eval_results.yaml.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class EvalResultEntry:
+    """
+    Evaluation result entry for the `.eval_results/*.yaml` format.
+
+    Represents evaluation scores stored in model repos that automatically appear on
+    the model page and the benchmark dataset's leaderboard.
+
+    For the legacy `model-index` format in `README.md`, use [`EvalResult`] instead.
+
+    See https://huggingface.co/docs/hub/eval-results for more details.
+
+    Args:
+        dataset_id (`str`):
+            Benchmark dataset ID from the Hub. Example: "cais/hle", "Idavidrein/gpqa".
+        task_id (`str`):
+            Task identifier within the benchmark. Example: "gpqa_diamond".
+        value (`Any`):
+            The metric value. Example: 20.90.
+        dataset_revision (`str`, *optional*):
+            Git SHA of the benchmark dataset.
+        verify_token (`str`, *optional*):
+            A signature that can be used to prove that evaluation is provably auditable and reproducible.
+        date (`str`, *optional*):
+            When the evaluation was run (ISO-8601 datetime). Defaults to git commit time.
+        source_url (`str`, *optional*):
+            Link to the evaluation source (e.g., https://huggingface.co/spaces/SaylorTwift/smollm3-mmlu-pro). Required if `source_name`, `source_user`, or `source_org` is provided.
+        source_name (`str`, *optional*):
+            Display name for the source. Example: "Eval Logs".
+        source_user (`str`, *optional*):
+            HF user name for attribution. Example: "celinah".
+        source_org (`str`, *optional*):
+            HF org name for attribution. Example: "cais".
+        notes (`str`, *optional*):
+            Details about the evaluation setup. Example: "tools", "no-tools", "chain-of-thought".
+
+    Example:
+        ```python
+        >>> from huggingface_hub import EvalResultEntry
+        >>> # Minimal example with required fields only
+        >>> result = EvalResultEntry(
+        ...     dataset_id="Idavidrein/gpqa",
+        ...     task_id="gpqa_diamond",
+        ...     value=0.412,
+        ... )
+        >>> # Full example with all fields
+        >>> result = EvalResultEntry(
+        ...     dataset_id="cais/hle",
+        ...     task_id="default",
+        ...     value=20.90,
+        ...     dataset_revision="5503434ddd753f426f4b38109466949a1217c2bb",
+        ...     verify_token="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+        ...     date="2025-01-15T10:30:00Z",
+        ...     source_url="https://huggingface.co/datasets/cais/hle",
+        ...     source_name="CAIS HLE",
+        ...     source_org="cais",
+        ...     notes="no-tools",
+        ... )
+
+        ```
+    """
+
+    dataset_id: str
+    task_id: str
+    value: Any
+    dataset_revision: str | None = None
+    verify_token: str | None = None
+    date: str | None = None
+    source_url: str | None = None
+    source_name: str | None = None
+    source_user: str | None = None
+    source_org: str | None = None
+    notes: str | None = None
+
+    def __post_init__(self) -> None:
+        if (
+            self.source_name is not None or self.source_user is not None or self.source_org is not None
+        ) and self.source_url is None:
+            raise ValueError(
+                "If `source_name`, `source_user`, or `source_org` is provided, `source_url` must also be provided."
+            )
+
+
+def eval_result_entries_to_yaml(entries: list[EvalResultEntry]) -> list[dict[str, Any]]:
+    """Convert a list of [`EvalResultEntry`] objects to a YAML-serializable list of dicts.
+
+    This produces the format expected in `.eval_results/*.yaml` files.
+
+    Args:
+        entries (`list[EvalResultEntry]`):
+            List of evaluation result entries to serialize.
+
+    Returns:
+        `list[dict[str, Any]]`: A list of dictionaries ready to be dumped to YAML.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import EvalResultEntry, eval_result_entries_to_yaml
+        >>> entries = [
+        ...     EvalResultEntry(dataset_id="cais/hle", task_id="default", value=20.90),
+        ...     EvalResultEntry(dataset_id="Idavidrein/gpqa", task_id="gpqa_diamond", value=0.412),
+        ... ]
+        >>> yaml_data = eval_result_entries_to_yaml(entries)
+        >>> yaml_data[0]
+        {'dataset': {'id': 'cais/hle', 'task_id': 'default'}, 'value': 20.9}
+
+        ```
+
+        To upload eval results to the Hub:
+        ```python
+        >>> import yaml
+        >>> from huggingface_hub import upload_file, EvalResultEntry, eval_result_entries_to_yaml
+        >>> entries = [
+        ...     EvalResultEntry(dataset_id="cais/hle", task_id="default", value=20.90),
+        ... ]
+        >>> yaml_content = yaml.dump(eval_result_entries_to_yaml(entries))
+        >>> upload_file(
+        ...     path_or_fileobj=yaml_content.encode(),
+        ...     path_in_repo=".eval_results/hle.yaml",
+        ...     repo_id="your-username/your-model",
+        ... )
+
+        ```
+    """
+    result = []
+    for entry in entries:
+        # build the dataset object
+        dataset: dict[str, Any] = {"id": entry.dataset_id, "task_id": entry.task_id}
+        if entry.dataset_revision is not None:
+            dataset["revision"] = entry.dataset_revision
+
+        data: dict[str, Any] = {"dataset": dataset, "value": entry.value}
+        if entry.verify_token is not None:
+            data["verifyToken"] = entry.verify_token
+        if entry.date is not None:
+            data["date"] = entry.date
+        # build the source object
+        if entry.source_url is not None:
+            source: dict[str, Any] = {"url": entry.source_url}
+            if entry.source_name is not None:
+                source["name"] = entry.source_name
+            if entry.source_user is not None:
+                source["user"] = entry.source_user
+            if entry.source_org is not None:
+                source["org"] = entry.source_org
+            data["source"] = source
+        if entry.notes is not None:
+            data["notes"] = entry.notes
+
+        result.append(data)
+    return result
+
+
+def parse_eval_result_entries(data: list[dict[str, Any]]) -> list[EvalResultEntry]:
+    """Parse a list of dicts into [`EvalResultEntry`] objects.
+
+    This parses the `.eval_results/*.yaml` format. For the legacy `model-index` format,
+    use [`model_index_to_eval_results`] instead.
+
+    Args:
+        data (`list[dict[str, Any]]`):
+            A list of dictionaries (e.g., parsed from YAML or API response).
+
+    Returns:
+        `list[EvalResultEntry]`: A list of evaluation result entry objects.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import parse_eval_result_entries
+        >>> data = [
+        ...     {"dataset": {"id": "cais/hle", "task_id": "default"}, "value": 20.90},
+        ...     {"dataset": {"id": "Idavidrein/gpqa", "task_id": "gpqa_diamond"}, "value": 0.412},
+        ... ]
+        >>> entries = parse_eval_result_entries(data)
+        >>> entries[0].dataset_id
+        'cais/hle'
+        >>> entries[0].value
+        20.9
+
+        ```
+    """
+    entries = []
+    for item in data:
+        entry_data = item.get("data", item)
+        dataset = entry_data.get("dataset", {})
+        source = entry_data.get("source", {})
+        entry = EvalResultEntry(
+            dataset_id=dataset["id"],
+            value=entry_data["value"],
+            task_id=dataset["task_id"],
+            dataset_revision=dataset.get("revision"),
+            verify_token=entry_data.get("verifyToken"),
+            date=entry_data.get("date"),
+            source_url=source.get("url") if source else None,
+            source_name=source.get("name") if source else None,
+            source_user=source.get("user") if source else None,
+            source_org=source.get("org") if source else None,
+            notes=entry_data.get("notes"),
+        )
+        entries.append(entry)
+    return entries

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/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.

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/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"}

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/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

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/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

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_inference_endpoints.py

@@ -0,0 +1,419 @@
+import time
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING, Optional
+
+from huggingface_hub.errors import InferenceEndpointError, InferenceEndpointTimeoutError
+
+from .utils import get_session, logging, parse_datetime
+
+
+if TYPE_CHECKING:
+    from .hf_api import HfApi
+    from .inference._client import InferenceClient
+    from .inference._generated._async_client import AsyncInferenceClient
+
+logger = logging.get_logger(__name__)
+
+
+class InferenceEndpointStatus(str, Enum):
+    PENDING = "pending"
+    INITIALIZING = "initializing"
+    UPDATING = "updating"
+    UPDATE_FAILED = "updateFailed"
+    RUNNING = "running"
+    PAUSED = "paused"
+    FAILED = "failed"
+    SCALED_TO_ZERO = "scaledToZero"
+
+
+class InferenceEndpointType(str, Enum):
+    PUBlIC = "public"
+    PROTECTED = "protected"  # deprecated, use AUTHENTICATED instead
+    AUTHENTICATED = "authenticated"
+    PRIVATE = "private"
+
+
+class InferenceEndpointScalingMetric(str, Enum):
+    PENDING_REQUESTS = "pendingRequests"
+    HARDWARE_USAGE = "hardwareUsage"
+
+
+@dataclass
+class InferenceEndpoint:
+    """
+    Contains information about a deployed Inference Endpoint.
+
+    Args:
+        name (`str`):
+            The unique name of the Inference Endpoint.
+        namespace (`str`):
+            The namespace where the Inference Endpoint is located.
+        repository (`str`):
+            The name of the model repository deployed on this Inference Endpoint.
+        status ([`InferenceEndpointStatus`]):
+            The current status of the Inference Endpoint.
+        url (`str`, *optional*):
+            The URL of the Inference Endpoint, if available. Only a deployed Inference Endpoint will have a URL.
+        framework (`str`):
+            The machine learning framework used for the model.
+        revision (`str`):
+            The specific model revision deployed on the Inference Endpoint.
+        task (`str`):
+            The task associated with the deployed model.
+        created_at (`datetime.datetime`):
+            The timestamp when the Inference Endpoint was created.
+        updated_at (`datetime.datetime`):
+            The timestamp of the last update of the Inference Endpoint.
+        type ([`InferenceEndpointType`]):
+            The type of the Inference Endpoint (public, authenticated, private).
+        raw (`dict`):
+            The raw dictionary data returned from the API.
+        token (`str` or `bool`, *optional*):
+            Authentication token for the Inference Endpoint, if set when requesting the API. Will default to the
+            locally saved token if not provided. Pass `token=False` if you don't want to send your token to the server.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import get_inference_endpoint
+        >>> endpoint = get_inference_endpoint("my-text-to-image")
+        >>> endpoint
+        InferenceEndpoint(name='my-text-to-image', ...)
+
+        # Get status
+        >>> endpoint.status
+        'running'
+        >>> endpoint.url
+        'https://my-text-to-image.region.vendor.endpoints.huggingface.cloud'
+
+        # Run inference
+        >>> endpoint.client.text_to_image(...)
+
+        # Pause endpoint to save $$$
+        >>> endpoint.pause()
+
+        # ...
+        # Resume and wait for deployment
+        >>> endpoint.resume()
+        >>> endpoint.wait()
+        >>> endpoint.client.text_to_image(...)
+        ```
+    """
+
+    # Field in __repr__
+    name: str = field(init=False)
+    namespace: str
+    repository: str = field(init=False)
+    status: InferenceEndpointStatus = field(init=False)
+    health_route: str = field(init=False)
+    url: str | None = field(init=False)
+
+    # Other fields
+    framework: str = field(repr=False, init=False)
+    revision: str = field(repr=False, init=False)
+    task: str = field(repr=False, init=False)
+    created_at: datetime = field(repr=False, init=False)
+    updated_at: datetime = field(repr=False, init=False)
+    type: InferenceEndpointType = field(repr=False, init=False)
+
+    # Raw dict from the API
+    raw: dict = field(repr=False)
+
+    # Internal fields
+    _token: str | bool | None = field(repr=False, compare=False)
+    _api: "HfApi" = field(repr=False, compare=False)
+
+    @classmethod
+    def from_raw(
+        cls, raw: dict, namespace: str, token: str | bool | None = None, api: Optional["HfApi"] = None
+    ) -> "InferenceEndpoint":
+        """Initialize object from raw dictionary."""
+        if api is None:
+            from .hf_api import HfApi
+
+            api = HfApi()
+        if token is None:
+            token = api.token
+
+        # All other fields are populated in __post_init__
+        return cls(raw=raw, namespace=namespace, _token=token, _api=api)
+
+    def __post_init__(self) -> None:
+        """Populate fields from raw dictionary."""
+        self._populate_from_raw()
+
+    @property
+    def client(self) -> "InferenceClient":
+        """Returns a client to make predictions on this Inference Endpoint.
+
+        Returns:
+            [`InferenceClient`]: an inference client pointing to the deployed endpoint.
+
+        Raises:
+            [`InferenceEndpointError`]: If the Inference Endpoint is not yet deployed.
+        """
+        if self.url is None:
+            raise InferenceEndpointError(
+                "Cannot create a client for this Inference Endpoint as it is not yet deployed. "
+                "Please wait for the Inference Endpoint to be deployed using `endpoint.wait()` and try again."
+            )
+        from .inference._client import InferenceClient
+
+        return InferenceClient(
+            model=self.url,
+            token=self._token,  # type: ignore # boolean token shouldn't be possible. In practice it's ok.
+        )
+
+    @property
+    def async_client(self) -> "AsyncInferenceClient":
+        """Returns a client to make predictions on this Inference Endpoint.
+
+        Returns:
+            [`AsyncInferenceClient`]: an asyncio-compatible inference client pointing to the deployed endpoint.
+
+        Raises:
+            [`InferenceEndpointError`]: If the Inference Endpoint is not yet deployed.
+        """
+        if self.url is None:
+            raise InferenceEndpointError(
+                "Cannot create a client for this Inference Endpoint as it is not yet deployed. "
+                "Please wait for the Inference Endpoint to be deployed using `endpoint.wait()` and try again."
+            )
+        from .inference._generated._async_client import AsyncInferenceClient
+
+        return AsyncInferenceClient(
+            model=self.url,
+            token=self._token,  # type: ignore # boolean token shouldn't be possible. In practice it's ok.
+        )
+
+    def wait(self, timeout: int | None = None, refresh_every: int = 5) -> "InferenceEndpoint":
+        """Wait for the Inference Endpoint to be deployed.
+
+        Information from the server will be fetched every 1s. If the Inference Endpoint is not deployed after `timeout`
+        seconds, a [`InferenceEndpointTimeoutError`] will be raised. The [`InferenceEndpoint`] will be mutated in place with the latest
+        data.
+
+        Args:
+            timeout (`int`, *optional*):
+                The maximum time to wait for the Inference Endpoint to be deployed, in seconds. If `None`, will wait
+                indefinitely.
+            refresh_every (`int`, *optional*):
+                The time to wait between each fetch of the Inference Endpoint status, in seconds. Defaults to 5s.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+
+        Raises:
+            [`InferenceEndpointError`]
+                If the Inference Endpoint ended up in a failed state.
+            [`InferenceEndpointTimeoutError`]
+                If the Inference Endpoint is not deployed after `timeout` seconds.
+        """
+        if timeout is not None and timeout < 0:
+            raise ValueError("`timeout` cannot be negative.")
+        if refresh_every <= 0:
+            raise ValueError("`refresh_every` must be positive.")
+
+        start = time.time()
+        while True:
+            if self.status == InferenceEndpointStatus.FAILED:
+                raise InferenceEndpointError(
+                    f"Inference Endpoint {self.name} failed to deploy. Please check the logs for more information."
+                )
+            if self.status == InferenceEndpointStatus.UPDATE_FAILED:
+                raise InferenceEndpointError(
+                    f"Inference Endpoint {self.name} failed to update. Please check the logs for more information."
+                )
+            if self.status == InferenceEndpointStatus.RUNNING and self.url is not None:
+                # Verify the endpoint is actually reachable
+                _health_url = f"{self.url.rstrip('/')}/{self.health_route.lstrip('/')}"
+                response = get_session().get(_health_url, headers=self._api._build_hf_headers(token=self._token))
+                if response.status_code == 200:
+                    logger.info("Inference Endpoint is ready to be used.")
+                    return self
+
+            if timeout is not None:
+                if time.time() - start > timeout:
+                    raise InferenceEndpointTimeoutError("Timeout while waiting for Inference Endpoint to be deployed.")
+            logger.info(f"Inference Endpoint is not deployed yet ({self.status}). Waiting {refresh_every}s...")
+            time.sleep(refresh_every)
+            self.fetch()
+
+    def fetch(self) -> "InferenceEndpoint":
+        """Fetch latest information about the Inference Endpoint.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        obj = self._api.get_inference_endpoint(name=self.name, namespace=self.namespace, token=self._token)  # type: ignore [arg-type]
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def update(
+        self,
+        *,
+        # Compute update
+        accelerator: str | None = None,
+        instance_size: str | None = None,
+        instance_type: str | None = None,
+        min_replica: int | None = None,
+        max_replica: int | None = None,
+        scale_to_zero_timeout: int | None = None,
+        # Model update
+        repository: str | None = None,
+        framework: str | None = None,
+        revision: str | None = None,
+        task: str | None = None,
+        custom_image: dict | None = None,
+        secrets: dict[str, str] | None = None,
+    ) -> "InferenceEndpoint":
+        """Update the Inference Endpoint.
+
+        This method allows the update of either the compute configuration, the deployed model, or both. All arguments are
+        optional but at least one must be provided.
+
+        This is an alias for [`HfApi.update_inference_endpoint`]. The current object is mutated in place with the
+        latest data from the server.
+
+        Args:
+            accelerator (`str`, *optional*):
+                The hardware accelerator to be used for inference (e.g. `"cpu"`).
+            instance_size (`str`, *optional*):
+                The size or type of the instance to be used for hosting the model (e.g. `"x4"`).
+            instance_type (`str`, *optional*):
+                The cloud instance type where the Inference Endpoint will be deployed (e.g. `"intel-icl"`).
+            min_replica (`int`, *optional*):
+                The minimum number of replicas (instances) to keep running for the Inference Endpoint.
+            max_replica (`int`, *optional*):
+                The maximum number of replicas (instances) to scale to for the Inference Endpoint.
+            scale_to_zero_timeout (`int`, *optional*):
+                The duration in minutes before an inactive endpoint is scaled to zero.
+
+            repository (`str`, *optional*):
+                The name of the model repository associated with the Inference Endpoint (e.g. `"gpt2"`).
+            framework (`str`, *optional*):
+                The machine learning framework used for the model (e.g. `"custom"`).
+            revision (`str`, *optional*):
+                The specific model revision to deploy on the Inference Endpoint (e.g. `"6c0e6080953db56375760c0471a8c5f2929baf11"`).
+            task (`str`, *optional*):
+                The task on which to deploy the model (e.g. `"text-classification"`).
+            custom_image (`dict`, *optional*):
+                A custom Docker image to use for the Inference Endpoint. This is useful if you want to deploy an
+                Inference Endpoint running on the `text-generation-inference` (TGI) framework (see examples).
+            secrets (`dict[str, str]`, *optional*):
+                Secret values to inject in the container environment.
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        # Make API call
+        obj = self._api.update_inference_endpoint(
+            name=self.name,
+            namespace=self.namespace,
+            accelerator=accelerator,
+            instance_size=instance_size,
+            instance_type=instance_type,
+            min_replica=min_replica,
+            max_replica=max_replica,
+            scale_to_zero_timeout=scale_to_zero_timeout,
+            repository=repository,
+            framework=framework,
+            revision=revision,
+            task=task,
+            custom_image=custom_image,
+            secrets=secrets,
+            token=self._token,  # type: ignore [arg-type]
+        )
+
+        # Mutate current object
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def pause(self) -> "InferenceEndpoint":
+        """Pause the Inference Endpoint.
+
+        A paused Inference Endpoint will not be charged. It can be resumed at any time using [`InferenceEndpoint.resume`].
+        This is different from scaling the Inference Endpoint to zero with [`InferenceEndpoint.scale_to_zero`], which
+        would be automatically restarted when a request is made to it.
+
+        This is an alias for [`HfApi.pause_inference_endpoint`]. The current object is mutated in place with the
+        latest data from the server.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        obj = self._api.pause_inference_endpoint(name=self.name, namespace=self.namespace, token=self._token)  # type: ignore [arg-type]
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def resume(self, running_ok: bool = True) -> "InferenceEndpoint":
+        """Resume the Inference Endpoint.
+
+        This is an alias for [`HfApi.resume_inference_endpoint`]. The current object is mutated in place with the
+        latest data from the server.
+
+        Args:
+            running_ok (`bool`, *optional*):
+                If `True`, the method will not raise an error if the Inference Endpoint is already running. Defaults to
+                `True`.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        obj = self._api.resume_inference_endpoint(
+            name=self.name, namespace=self.namespace, running_ok=running_ok, token=self._token
+        )  # type: ignore [arg-type]
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def scale_to_zero(self) -> "InferenceEndpoint":
+        """Scale Inference Endpoint to zero.
+
+        An Inference Endpoint scaled to zero will not be charged. It will be resumed on the next request to it, with a
+        cold start delay. This is different from pausing the Inference Endpoint with [`InferenceEndpoint.pause`], which
+        would require a manual resume with [`InferenceEndpoint.resume`].
+
+        This is an alias for [`HfApi.scale_to_zero_inference_endpoint`]. The current object is mutated in place with the
+        latest data from the server.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        obj = self._api.scale_to_zero_inference_endpoint(name=self.name, namespace=self.namespace, token=self._token)  # type: ignore [arg-type]
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def delete(self) -> None:
+        """Delete the Inference Endpoint.
+
+        This operation is not reversible. If you don't want to be charged for an Inference Endpoint, it is preferable
+        to pause it with [`InferenceEndpoint.pause`] or scale it to zero with [`InferenceEndpoint.scale_to_zero`].
+
+        This is an alias for [`HfApi.delete_inference_endpoint`].
+        """
+        self._api.delete_inference_endpoint(name=self.name, namespace=self.namespace, token=self._token)  # type: ignore [arg-type]
+
+    def _populate_from_raw(self) -> None:
+        """Populate fields from raw dictionary.
+
+        Called in __post_init__ + each time the Inference Endpoint is updated.
+        """
+        # Repr fields
+        self.name = self.raw["name"]
+        self.repository = self.raw["model"]["repository"]
+        self.status = self.raw["status"]["state"]
+        self.url = self.raw["status"].get("url")
+        self.health_route = self.raw["healthRoute"]
+
+        # Other fields
+        self.framework = self.raw["model"]["framework"]
+        self.revision = self.raw["model"]["revision"]
+        self.task = self.raw["model"]["task"]
+        self.created_at = parse_datetime(self.raw["status"]["createdAt"])
+        self.updated_at = parse_datetime(self.raw["status"]["updatedAt"])
+        self.type = self.raw["type"]

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_jobs_api.py

@@ -0,0 +1,567 @@
+# 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.
+import hashlib
+import platform
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from huggingface_hub import constants
+from huggingface_hub._space_api import Volume
+from huggingface_hub.utils._datetime import parse_datetime
+
+
+class JobHardware(str, Enum):
+    """
+    Enumeration of hardware flavors available to run Jobs on the Hub.
+
+    Value can be compared to a string:
+    ```py
+    assert JobHardware.CPU_BASIC == "cpu-basic"
+    ```
+
+    Both enums are kept in sync with the Hub API by `utils/check_hardware_flavors.py`.
+    """
+
+    # CPU
+    CPU_BASIC = "cpu-basic"
+    CPU_UPGRADE = "cpu-upgrade"
+    CPU_PERFORMANCE = "cpu-performance"
+    CPU_XL = "cpu-xl"
+
+    # GPU
+    T4_SMALL = "t4-small"
+    T4_MEDIUM = "t4-medium"
+    L4X1 = "l4x1"
+    L4X4 = "l4x4"
+    L40SX1 = "l40sx1"
+    L40SX4 = "l40sx4"
+    L40SX8 = "l40sx8"
+    A10G_SMALL = "a10g-small"
+    A10G_LARGE = "a10g-large"
+    A10G_LARGEX2 = "a10g-largex2"
+    A10G_LARGEX4 = "a10g-largex4"
+    A100_LARGE = "a100-large"
+    A100X4 = "a100x4"
+    A100X8 = "a100x8"
+    H200 = "h200"
+    H200X2 = "h200x2"
+    H200X4 = "h200x4"
+    H200X8 = "h200x8"
+    RTX_PRO_6000 = "rtx-pro-6000"
+    RTX_PRO_6000X2 = "rtx-pro-6000x2"
+    RTX_PRO_6000X4 = "rtx-pro-6000x4"
+    RTX_PRO_6000X8 = "rtx-pro-6000x8"
+
+
+class JobStage(str, Enum):
+    """
+    Enumeration of possible stage of a Job on the Hub.
+
+    Value can be compared to a string:
+    ```py
+    assert JobStage.COMPLETED == "COMPLETED"
+    ```
+    Possible values are: `COMPLETED`, `CANCELED`, `ERROR`, `DELETED`, `SCHEDULING`, `RUNNING`.
+    Taken from https://github.com/huggingface/moon-landing/blob/main/server/job_types/JobInfo.ts#L61 (private url).
+    """
+
+    # Copied from moon-landing > server > lib > Job.ts
+    COMPLETED = "COMPLETED"
+    CANCELED = "CANCELED"
+    ERROR = "ERROR"
+    DELETED = "DELETED"
+    SCHEDULING = "SCHEDULING"
+    RUNNING = "RUNNING"
+
+
+# Stages indicating the Job has reached a terminal state and will not run further.
+TERMINAL_JOB_STAGES = (JobStage.COMPLETED, JobStage.CANCELED, JobStage.ERROR, JobStage.DELETED)
+
+
+@dataclass
+class JobStatus:
+    stage: JobStage
+    message: str | None
+    expose_urls: list[str] | None
+    ssh_url: str | None
+
+
+@dataclass
+class JobOwner:
+    id: str
+    name: str
+    type: str
+
+
+@dataclass
+class JobDurations:
+    """
+    Timing breakdown for a Job, computed server-side.
+
+    Args:
+        scheduling_secs (`int` or `None`):
+            Seconds the job spent in the scheduling stage before starting to run.
+            `None` if the job never reached the running stage.
+        running_secs (`int` or `None`):
+            Seconds the job has been or was running. Recomputed on each request
+            while the job is in progress. `None` if the job never started running.
+        total_secs (`int` or `None`):
+            Total seconds elapsed since the job was created. Recomputed on each
+            request while the job is in progress.
+    """
+
+    scheduling_secs: int | None
+    running_secs: int | None
+    total_secs: int | None
+
+    def __init__(self, **kwargs) -> None:
+        self.scheduling_secs = kwargs.get("schedulingSecs", kwargs.get("scheduling_secs"))
+        self.running_secs = kwargs.get("runningSecs", kwargs.get("running_secs"))
+        self.total_secs = kwargs.get("totalSecs", kwargs.get("total_secs"))
+
+
+@dataclass
+class JobInitiator:
+    """
+    Contains information about what triggered a Job.
+
+    Args:
+        type (`str`): Initiator kind, for example `"user"`, `"org"`, `"scheduled-job"`, or `"duplicated-job"`.
+        id (`str`): Identifier of the initiator.
+        name (`str` or `None`): Human-readable name when available, usually for user/org initiators.
+    """
+
+    type: str
+    id: str
+    name: str | None = None
+
+
+@dataclass
+class JobInfo:
+    """
+    Contains information about a Job.
+
+    Args:
+        id (`str`):
+            Job ID.
+        created_at (`datetime` or `None`):
+            When the Job was created.
+        started_at (`datetime` or `None`):
+            When the Job started running. None while the Job is still scheduling.
+        finished_at (`datetime` or `None`):
+            When the Job finished. None while the Job is still scheduling or running.
+        docker_image (`str` or `None`):
+            The Docker image from Docker Hub used for the Job.
+            Can be None if space_id is present instead.
+        space_id (`str` or `None`):
+            The Docker image from Hugging Face Spaces used for the Job.
+            Can be None if docker_image is present instead.
+        command (`list[str]` or `None`):
+            Command of the Job, e.g. `["python", "-c", "print('hello world')"]`
+        arguments (`list[str]` or `None`):
+            Arguments passed to the command
+        environment (`dict[str]` or `None`):
+            Environment variables of the Job as a dictionary.
+        secrets (`dict[str]` or `None`):
+            Secret environment variables of the Job (encrypted).
+        flavor (`str` or `None`):
+            Flavor for the hardware. See [`JobHardware`] for possible values.
+            E.g. `"cpu-basic"`.
+        labels (`dict[str, str]` or `None`):
+            Labels to attach to the job (key-value pairs).
+        volumes (`list[Volume]` or `None`):
+            Volumes mounted in the job container (buckets, models, datasets, spaces).
+        status: (`JobStatus` or `None`):
+            Status of the Job, e.g. `JobStatus(stage="RUNNING", message=None)`
+            See [`JobStage`] for possible stage values.
+        durations (`JobDurations` or `None`):
+            Timing breakdown of the Job. Present for all job states including SCHEDULING.
+        owner: (`JobOwner` or `None`):
+            Owner of the Job, e.g. `JobOwner(id="5e9ecfc04957053f60648a3e", name="lhoestq", type="user")`
+        initiator (`JobInitiator` or `None`):
+            What triggered the Job, e.g. `JobInitiator(type="scheduled-job", id="...")` for a cron-triggered run.
+        expose_urls (`list[str]` or `None`):
+            Public URLs through which the Job's exposed ports are reachable (one per port exposed via `expose=`),
+            e.g. `["https://687fb701029421ae5549d998--8000.hf.jobs"]`. `None` when no port is exposed.
+            Accessing a URL requires an HF token with read access to the Job's namespace.
+        ssh_url (`str` or `None`):
+            SSH endpoint of the Job, e.g. `"ssh://687fb701029421ae5549d998@ssh.hf.jobs"`. Only present when the Job
+            was started with `ssh=True`. Connecting requires write access to the Job's namespace and an SSH public
+            key registered on the Hub (https://huggingface.co/settings/keys).
+
+    Example:
+
+    ```python
+    >>> from huggingface_hub import run_job
+    >>> job = run_job(
+    ...     image="python:3.12",
+    ...     command=["python", "-c", "print('Hello from the cloud!')"]
+    ... )
+    >>> job
+    JobInfo(id='687fb701029421ae5549d998', created_at=datetime.datetime(2025, 7, 22, 16, 6, 25, 79000, tzinfo=datetime.timezone.utc), started_at=datetime.datetime(2025, 7, 22, 16, 6, 31, 79000, tzinfo=datetime.timezone.utc), finished_at=None, docker_image='python:3.12', space_id=None, command=['python', '-c', "print('Hello from the cloud!')"], arguments=[], environment={}, secrets={}, flavor='cpu-basic', labels=None, status=JobStatus(stage='RUNNING', message=None), durations=JobDurations(scheduling_secs=6, running_secs=2, total_secs=8), owner=JobOwner(id='5e9ecfc04957053f60648a3e', name='lhoestq', type='user'), initiator=JobInitiator(type='user', id='5e9ecfc04957053f60648a3e', name='lhoestq'), endpoint='https://huggingface.co', url='https://huggingface.co/jobs/lhoestq/687fb701029421ae5549d998')
+    >>> job.id
+    '687fb701029421ae5549d998'
+    >>> job.url
+    'https://huggingface.co/jobs/lhoestq/687fb701029421ae5549d998'
+    >>> job.status.stage
+    'RUNNING'
+    ```
+    """
+
+    id: str
+    created_at: datetime | None
+    started_at: datetime | None
+    finished_at: datetime | None
+    docker_image: str | None
+    space_id: str | None
+    command: list[str] | None
+    arguments: list[str] | None
+    environment: dict[str, Any] | None
+    secrets: dict[str, Any] | None
+    flavor: JobHardware | None
+    labels: dict[str, str] | None
+    volumes: list[Volume] | None
+    status: JobStatus
+    durations: JobDurations | None
+    owner: JobOwner
+    initiator: JobInitiator | None
+
+    # Inferred fields
+    endpoint: str
+    url: str
+
+    def __init__(self, **kwargs) -> None:
+        self.id = kwargs["id"]
+        created_at = kwargs.get("createdAt") or kwargs.get("created_at")
+        self.created_at = parse_datetime(created_at) if created_at else None
+        started_at = kwargs.get("startedAt") or kwargs.get("started_at")
+        self.started_at = parse_datetime(started_at) if started_at else None
+        finished_at = kwargs.get("finishedAt") or kwargs.get("finished_at")
+        self.finished_at = parse_datetime(finished_at) if finished_at else None
+        self.docker_image = kwargs.get("dockerImage") or kwargs.get("docker_image")
+        self.space_id = kwargs.get("spaceId") or kwargs.get("space_id")
+        owner = kwargs.get("owner", {})
+        self.owner = JobOwner(id=owner["id"], name=owner["name"], type=owner["type"])
+        self.command = kwargs.get("command")
+        self.arguments = kwargs.get("arguments")
+        self.environment = kwargs.get("environment")
+        self.secrets = kwargs.get("secrets")
+        self.flavor = kwargs.get("flavor")
+        self.labels = kwargs.get("labels")
+        volumes = kwargs.get("volumes")
+        self.volumes = [Volume(**v) for v in volumes] if volumes else None
+        status = kwargs.get("status", {})
+        self.status = JobStatus(
+            stage=status["stage"],
+            message=status.get("message"),
+            expose_urls=status.get("exposeUrls"),
+            ssh_url=status.get("sshUrl"),
+        )
+        durations = kwargs.get("durations")
+        self.durations = JobDurations(**durations) if durations else None
+        initiator = kwargs.get("initiator")
+        self.initiator = (
+            JobInitiator(type=initiator["type"], id=initiator["id"], name=initiator.get("name")) if initiator else None
+        )
+
+        # Inferred fields
+        self.endpoint = kwargs.get("endpoint", constants.ENDPOINT)
+        self.url = f"{self.endpoint}/jobs/{self.owner.name}/{self.id}"
+
+
+@dataclass
+class JobSpec:
+    docker_image: str | None
+    space_id: str | None
+    command: list[str] | None
+    arguments: list[str] | None
+    environment: dict[str, Any] | None
+    secrets: dict[str, Any] | None
+    flavor: JobHardware | None
+    timeout: int | None
+    tags: list[str] | None
+    arch: str | None
+    labels: dict[str, str] | None
+    volumes: list[Volume] | None
+
+    def __init__(self, **kwargs) -> None:
+        self.docker_image = kwargs.get("dockerImage") or kwargs.get("docker_image")
+        self.space_id = kwargs.get("spaceId") or kwargs.get("space_id")
+        self.command = kwargs.get("command")
+        self.arguments = kwargs.get("arguments")
+        self.environment = kwargs.get("environment")
+        self.secrets = kwargs.get("secrets")
+        self.flavor = kwargs.get("flavor")
+        self.timeout = kwargs.get("timeout")
+        self.tags = kwargs.get("tags")
+        self.arch = kwargs.get("arch")
+        self.labels = kwargs.get("labels")
+        volumes = kwargs.get("volumes")
+        self.volumes = [Volume(**v) for v in volumes] if volumes else None
+
+
+@dataclass
+class LastJobInfo:
+    id: str
+    at: datetime
+
+    def __init__(self, **kwargs) -> None:
+        self.id = kwargs["id"]
+        self.at = parse_datetime(kwargs["at"])
+
+
+@dataclass
+class ScheduledJobStatus:
+    last_job: LastJobInfo | None
+    next_job_run_at: datetime | None
+
+    def __init__(self, **kwargs) -> None:
+        last_job = kwargs.get("lastJob") or kwargs.get("last_job")
+        self.last_job = LastJobInfo(**last_job) if last_job else None
+        next_job_run_at = kwargs.get("nextJobRunAt") or kwargs.get("next_job_run_at")
+        self.next_job_run_at = parse_datetime(str(next_job_run_at)) if next_job_run_at else None
+
+
+@dataclass
+class ScheduledJobInfo:
+    """
+    Contains information about a Job.
+
+    Args:
+        id (`str`):
+            Scheduled Job ID.
+        created_at (`datetime` or `None`):
+            When the scheduled Job was created.
+        tags (`list[str]` or `None`):
+            The tags of the scheduled Job.
+        schedule (`str` or `None`):
+            One of "@annually", "@yearly", "@monthly", "@weekly", "@daily", "@hourly", or a
+            CRON schedule expression (e.g., '0 9 * * 1' for 9 AM every Monday).
+        suspend (`bool` or `None`):
+            Whether the scheduled job is suspended (paused).
+        concurrency (`bool` or `None`):
+            Whether multiple instances of this Job can run concurrently.
+        status (`ScheduledJobStatus` or `None`):
+            Status of the scheduled Job.
+        owner: (`JobOwner` or `None`):
+            Owner of the scheduled Job, e.g. `JobOwner(id="5e9ecfc04957053f60648a3e", name="lhoestq", type="user")`
+        job_spec: (`JobSpec` or `None`):
+            Specifications of the Job.
+
+    Example:
+
+    ```python
+    >>> from huggingface_hub import run_job
+    >>> scheduled_job = create_scheduled_job(
+    ...     image="python:3.12",
+    ...     command=["python", "-c", "print('Hello from the cloud!')"],
+    ...     schedule="@hourly",
+    ... )
+    >>> scheduled_job.id
+    '687fb701029421ae5549d999'
+    >>> scheduled_job.status.next_job_run_at
+    datetime.datetime(2025, 7, 22, 17, 6, 25, 79000, tzinfo=datetime.timezone.utc)
+    ```
+    """
+
+    id: str
+    created_at: datetime | None
+    job_spec: JobSpec
+    schedule: str | None
+    suspend: bool | None
+    concurrency: bool | None
+    status: ScheduledJobStatus
+    owner: JobOwner
+
+    def __init__(self, **kwargs) -> None:
+        self.id = kwargs["id"]
+        created_at = kwargs.get("createdAt") or kwargs.get("created_at")
+        self.created_at = parse_datetime(created_at) if created_at else None
+        self.job_spec = JobSpec(**(kwargs.get("job_spec") or kwargs.get("jobSpec", {})))
+        self.schedule = kwargs.get("schedule")
+        self.suspend = kwargs.get("suspend")
+        self.concurrency = kwargs.get("concurrency")
+        status = kwargs.get("status", {})
+        self.status = ScheduledJobStatus(
+            last_job=status.get("last_job") or status.get("lastJob"),
+            next_job_run_at=status.get("next_job_run_at") or status.get("nextJobRunAt"),
+        )
+        owner = kwargs.get("owner", {})
+        self.owner = JobOwner(id=owner["id"], name=owner["name"], type=owner["type"])
+
+
+@dataclass
+class JobAccelerator:
+    """
+    Contains information about a Job accelerator (GPU).
+
+    Args:
+        type (`str`):
+            Type of accelerator, e.g. `"gpu"`.
+        model (`str`):
+            Model of accelerator, e.g. `"T4"`, `"A10G"`, `"A100"`, `"L4"`, `"L40S"`.
+        quantity (`str`):
+            Number of accelerators, e.g. `"1"`, `"2"`, `"4"`, `"8"`.
+        vram (`str`):
+            Total VRAM, e.g. `"16 GB"`, `"24 GB"`.
+        manufacturer (`str`):
+            Manufacturer of the accelerator, e.g. `"Nvidia"`.
+    """
+
+    type: str
+    model: str
+    quantity: str
+    vram: str
+    manufacturer: str
+
+    def __init__(self, **kwargs) -> None:
+        self.type = kwargs["type"]
+        self.model = kwargs["model"]
+        self.quantity = kwargs["quantity"]
+        self.vram = kwargs["vram"]
+        self.manufacturer = kwargs["manufacturer"]
+
+
+@dataclass
+class JobHardwareInfo:
+    """
+    Contains information about available Job hardware.
+
+    Args:
+        name (`str`):
+            Machine identifier, e.g. `"cpu-basic"`, `"a10g-large"`.
+        pretty_name (`str`):
+            Human-readable name, e.g. `"CPU Basic"`, `"Nvidia A10G - large"`.
+        cpu (`str`):
+            CPU specification, e.g. `"2 vCPU"`, `"12 vCPU"`.
+        ram (`str`):
+            RAM specification, e.g. `"16 GB"`, `"46 GB"`.
+        ephemeral_storage (`str`):
+            Ephemeral storage specification, e.g. `"20 GB"`, `"100 GB"`.
+        accelerator (`JobAccelerator` or `None`):
+            GPU/accelerator details if available.
+        unit_cost_micro_usd (`int`):
+            Cost in micro-dollars per unit, e.g. `167` (= $0.000167).
+        unit_cost_usd (`float`):
+            Cost in USD per unit, e.g. `0.000167`.
+        unit_label (`str`):
+            Cost unit period, e.g. `"minute"`.
+
+    Example:
+
+    ```python
+    >>> from huggingface_hub import list_jobs_hardware
+    >>> hardware_list = list_jobs_hardware()
+    >>> hardware_list[0]
+    JobHardwareInfo(name='cpu-basic', pretty_name='CPU Basic', cpu='2 vCPU', ram='16 GB', ephemeral_storage='20 GB', accelerator=None, unit_cost_micro_usd=167, unit_cost_usd=0.000167, unit_label='minute')
+    >>> hardware_list[0].name
+    'cpu-basic'
+    ```
+    """
+
+    name: str
+    pretty_name: str
+    cpu: str
+    ram: str
+    ephemeral_storage: str
+    accelerator: JobAccelerator | None
+    unit_cost_micro_usd: int
+    unit_cost_usd: float
+    unit_label: str
+
+    def __init__(self, **kwargs) -> None:
+        self.name = kwargs["name"]
+        self.pretty_name = kwargs["prettyName"]
+        self.cpu = kwargs["cpu"]
+        self.ram = kwargs["ram"]
+        self.ephemeral_storage = kwargs.get("ephemeralStorage", "N/A")
+        accelerator = kwargs.get("accelerator")
+        self.accelerator = JobAccelerator(**accelerator) if accelerator else None
+        self.unit_cost_micro_usd = kwargs["unitCostMicroUSD"]
+        self.unit_cost_usd = kwargs["unitCostUSD"]
+        self.unit_label = kwargs["unitLabel"]
+
+
+def _derive_job_volume_name(source: str | Path) -> str:
+    """Derive a stable remote folder name for a local directory synced as a Job volume.
+
+    The name is `{dirname}-{hash}` where the hash fingerprints the absolute path and the machine's
+    hostname: re-syncing the same directory from the same machine reuses the same remote folder
+    (so only changed files are re-uploaded), while same-named directories from different paths or
+    machines don't collide.
+    """
+    resolved = Path(source).expanduser().resolve()
+    digest = hashlib.sha256(f"{platform.node()}:{resolved}".encode()).hexdigest()[:8]
+    dirname = resolved.name.replace(" ", "_") or "root"
+    return f"{dirname}-{digest}"
+
+
+def _create_job_spec(
+    *,
+    image: str,
+    command: list[str],
+    env: dict[str, Any] | None,
+    secrets: dict[str, Any] | None,
+    flavor: JobHardware | str | None,
+    timeout: int | float | str | None,
+    labels: dict[str, str] | None = None,
+    volumes: list[Volume] | None = None,
+    expose: list[int] | None = None,
+    ssh: bool = False,
+) -> dict[str, Any]:
+    # prepare job spec to send to HF Jobs API
+    job_spec: dict[str, Any] = {
+        "command": command,
+        "arguments": [],
+        "environment": env or {},
+        "flavor": flavor or JobHardware.CPU_BASIC,
+    }
+    # secrets are optional
+    if secrets:
+        job_spec["secrets"] = secrets
+    # timeout is optional
+    if timeout:
+        time_units_factors = {"s": 1, "m": 60, "h": 3600, "d": 3600 * 24}
+        if isinstance(timeout, str) and timeout[-1] in time_units_factors:
+            job_spec["timeoutSeconds"] = int(float(timeout[:-1]) * time_units_factors[timeout[-1]])
+        else:
+            job_spec["timeoutSeconds"] = int(timeout)
+    # labels are optional
+    if labels:
+        job_spec["labels"] = labels
+    # volumes are optional
+    if volumes:
+        job_spec["volumes"] = [vol.to_dict() for vol in volumes]
+    # expose ports through the jobs proxy
+    if expose:
+        job_spec["expose"] = {"ports": expose}
+    # make the job container reachable over SSH
+    if ssh:
+        job_spec["ssh"] = {"enabled": True}
+    # input is either from docker hub or from HF spaces
+    for prefix in (
+        "https://huggingface.co/spaces/",
+        "https://hf.co/spaces/",
+        "huggingface.co/spaces/",
+        "hf.co/spaces/",
+    ):
+        if image.startswith(prefix):
+            job_spec["spaceId"] = image[len(prefix) :]
+            break
+    else:
+        job_spec["dockerImage"] = image
+    return job_spec

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_local_folder.py

@@ -0,0 +1,473 @@
+# Copyright 2024-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 utilities to handle the `../.cache/huggingface` folder in local directories.
+
+First discussed in https://github.com/huggingface/huggingface_hub/issues/1738 to store
+download metadata when downloading files from the hub to a local directory (without
+using the cache).
+
+./.cache/huggingface folder structure:
+[4.0K]  data
+├── [4.0K]  .cache
+│   └── [4.0K]  huggingface
+│       └── [4.0K]  download
+│           ├── [  16]  file.parquet.metadata
+│           ├── [  16]  file.txt.metadata
+│           └── [4.0K]  folder
+│               └── [  16]  file.parquet.metadata
+│
+├── [6.5G]  file.parquet
+├── [1.5K]  file.txt
+└── [4.0K]  folder
+    └── [   16]  file.parquet
+
+
+Download metadata file structure:
+```
+# file.txt.metadata
+11c5a3d5811f50298f278a704980280950aedb10
+a16a55fda99d2f2e7b69cce5cf93ff4ad3049930
+1712656091.123
+
+# file.parquet.metadata
+11c5a3d5811f50298f278a704980280950aedb10
+7c5d3f4b8b76583b422fcb9189ad6c89d5d97a094541ce8932dce3ecabde1421
+1712656091.123
+}
+```
+"""
+
+import base64
+import hashlib
+import logging
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .utils import WeakFileLock
+
+
+logger = logging.getLogger(__name__)
+
+CACHEDIR_TAG_CONTENT = (
+    "Signature: 8a477f597d28d172789f06886806bc55\n"
+    "# This file is a cache directory tag created by huggingface_hub.\n"
+    "# For information about cache directory tags, see:\n"
+    "#\thttps://bford.info/cachedir/\n"
+)
+
+
+@dataclass
+class LocalDownloadFilePaths:
+    """
+    Paths to the files related to a download process in a local dir.
+
+    Returned by [`get_local_download_paths`].
+
+    Attributes:
+        file_path (`Path`):
+            Path where the file will be saved.
+        lock_path (`Path`):
+            Path to the lock file used to ensure atomicity when reading/writing metadata.
+        metadata_path (`Path`):
+            Path to the metadata file.
+    """
+
+    file_path: Path
+    lock_path: Path
+    metadata_path: Path
+
+    def incomplete_path(self, etag: str) -> Path:
+        """Return the path where a file will be temporarily downloaded before being moved to `file_path`."""
+        path = self.metadata_path.parent / f"{_short_hash(self.metadata_path.name)}.{etag}.incomplete"
+        resolved_path = str(path.resolve())
+        # Some Windows versions do not allow for paths longer than 255 characters.
+        # In this case, we must specify it as an extended path by using the "\\?\" prefix.
+        if os.name == "nt" and len(resolved_path) > 255 and not resolved_path.startswith("\\\\?\\"):
+            path = Path("\\\\?\\" + resolved_path)
+        return path
+
+
+@dataclass(frozen=True)
+class LocalUploadFilePaths:
+    """
+    Paths to the files related to an upload process in a local dir.
+
+    Returned by [`get_local_upload_paths`].
+
+    Attributes:
+        path_in_repo (`str`):
+            Path of the file in the repo.
+        file_path (`Path`):
+            Path where the file will be saved.
+        lock_path (`Path`):
+            Path to the lock file used to ensure atomicity when reading/writing metadata.
+        metadata_path (`Path`):
+            Path to the metadata file.
+    """
+
+    path_in_repo: str
+    file_path: Path
+    lock_path: Path
+    metadata_path: Path
+
+
+@dataclass
+class LocalDownloadFileMetadata:
+    """
+    Metadata about a file in the local directory related to a download process.
+
+    Attributes:
+        filename (`str`):
+            Path of the file in the repo.
+        commit_hash (`str`):
+            Commit hash of the file in the repo.
+        etag (`str`):
+            ETag of the file in the repo. Used to check if the file has changed.
+            For LFS files, this is the sha256 of the file. For regular files, it corresponds to the git hash.
+        timestamp (`int`):
+            Unix timestamp of when the metadata was saved i.e. when the metadata was accurate.
+    """
+
+    filename: str
+    commit_hash: str
+    etag: str
+    timestamp: float
+
+
+@dataclass
+class LocalUploadFileMetadata:
+    """
+    Metadata about a file in the local directory related to an upload process.
+    """
+
+    size: int
+
+    # Default values correspond to "we don't know yet"
+    timestamp: float | None = None
+    should_ignore: bool | None = None
+    sha256: str | None = None
+    upload_mode: str | None = None
+    remote_oid: str | None = None
+    is_uploaded: bool = False
+    is_committed: bool = False
+
+    def save(self, paths: LocalUploadFilePaths) -> None:
+        """Save the metadata to disk."""
+        with WeakFileLock(paths.lock_path):
+            with paths.metadata_path.open("w") as f:
+                new_timestamp = time.time()
+                f.write(str(new_timestamp) + "\n")
+
+                f.write(str(self.size))  # never None
+                f.write("\n")
+
+                if self.should_ignore is not None:
+                    f.write(str(int(self.should_ignore)))
+                f.write("\n")
+
+                if self.sha256 is not None:
+                    f.write(self.sha256)
+                f.write("\n")
+
+                if self.upload_mode is not None:
+                    f.write(self.upload_mode)
+                f.write("\n")
+
+                if self.remote_oid is not None:
+                    f.write(self.remote_oid)
+                f.write("\n")
+
+                f.write(str(int(self.is_uploaded)) + "\n")
+                f.write(str(int(self.is_committed)) + "\n")
+
+            self.timestamp = new_timestamp
+
+
+def get_local_download_paths(local_dir: Path, filename: str) -> LocalDownloadFilePaths:
+    """Compute paths to the files related to a download process.
+
+    Folders containing the paths are all guaranteed to exist.
+
+    Args:
+        local_dir (`Path`):
+            Path to the local directory in which files are downloaded.
+        filename (`str`):
+            Path of the file in the repo.
+
+    Return:
+        [`LocalDownloadFilePaths`]: the paths to the files (file_path, lock_path, metadata_path, incomplete_path).
+    """
+    # filename is the path in the Hub repository (separated by '/')
+    # make sure to have a cross-platform transcription
+    sanitized_filename = os.path.join(*filename.split("/"))
+    if os.name == "nt":
+        if sanitized_filename.startswith("..\\") or "\\..\\" in sanitized_filename:
+            raise ValueError(
+                f"Invalid filename: cannot handle filename '{sanitized_filename}' on Windows. Please ask the repository"
+                " owner to rename this file."
+            )
+    file_path = local_dir / sanitized_filename
+    metadata_path = _huggingface_dir(local_dir) / "download" / f"{sanitized_filename}.metadata"
+    lock_path = metadata_path.with_suffix(".lock")
+
+    # Some Windows versions do not allow for paths longer than 255 characters.
+    # In this case, we must specify it as an extended path by using the "\\?\" prefix
+    if os.name == "nt":
+        if not str(local_dir).startswith("\\\\?\\") and len(os.path.abspath(lock_path)) > 255:
+            file_path = Path("\\\\?\\" + os.path.abspath(file_path))
+            lock_path = Path("\\\\?\\" + os.path.abspath(lock_path))
+            metadata_path = Path("\\\\?\\" + os.path.abspath(metadata_path))
+
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    metadata_path.parent.mkdir(parents=True, exist_ok=True)
+    return LocalDownloadFilePaths(file_path=file_path, lock_path=lock_path, metadata_path=metadata_path)
+
+
+def get_local_upload_paths(local_dir: Path, filename: str) -> LocalUploadFilePaths:
+    """Compute paths to the files related to an upload process.
+
+    Folders containing the paths are all guaranteed to exist.
+
+    Args:
+        local_dir (`Path`):
+            Path to the local directory that is uploaded.
+        filename (`str`):
+            Path of the file in the repo.
+
+    Return:
+        [`LocalUploadFilePaths`]: the paths to the files (file_path, lock_path, metadata_path).
+    """
+    # filename is the path in the Hub repository (separated by '/')
+    # make sure to have a cross-platform transcription
+    sanitized_filename = os.path.join(*filename.split("/"))
+    if os.name == "nt":
+        if sanitized_filename.startswith("..\\") or "\\..\\" in sanitized_filename:
+            raise ValueError(
+                f"Invalid filename: cannot handle filename '{sanitized_filename}' on Windows. Please ask the repository"
+                " owner to rename this file."
+            )
+    file_path = local_dir / sanitized_filename
+    metadata_path = _huggingface_dir(local_dir) / "upload" / f"{sanitized_filename}.metadata"
+    lock_path = metadata_path.with_suffix(".lock")
+
+    # Some Windows versions do not allow for paths longer than 255 characters.
+    # In this case, we must specify it as an extended path by using the "\\?\" prefix
+    if os.name == "nt":
+        if not str(local_dir).startswith("\\\\?\\") and len(os.path.abspath(lock_path)) > 255:
+            file_path = Path("\\\\?\\" + os.path.abspath(file_path))
+            lock_path = Path("\\\\?\\" + os.path.abspath(lock_path))
+            metadata_path = Path("\\\\?\\" + os.path.abspath(metadata_path))
+
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    metadata_path.parent.mkdir(parents=True, exist_ok=True)
+    return LocalUploadFilePaths(
+        path_in_repo=filename, file_path=file_path, lock_path=lock_path, metadata_path=metadata_path
+    )
+
+
+def read_download_metadata(local_dir: Path, filename: str) -> LocalDownloadFileMetadata | None:
+    """Read metadata about a file in the local directory related to a download process.
+
+    Args:
+        local_dir (`Path`):
+            Path to the local directory in which files are downloaded.
+        filename (`str`):
+            Path of the file in the repo.
+
+    Return:
+        `[LocalDownloadFileMetadata]` or `None`: the metadata if it exists, `None` otherwise.
+    """
+    paths = get_local_download_paths(local_dir, filename)
+    with WeakFileLock(paths.lock_path):
+        if paths.metadata_path.exists():
+            try:
+                with paths.metadata_path.open() as f:
+                    commit_hash = f.readline().strip()
+                    etag = f.readline().strip()
+                    timestamp = float(f.readline().strip())
+                    metadata = LocalDownloadFileMetadata(
+                        filename=filename,
+                        commit_hash=commit_hash,
+                        etag=etag,
+                        timestamp=timestamp,
+                    )
+            except Exception as e:
+                # remove the metadata file if it is corrupted / not the right format
+                logger.warning(
+                    f"Invalid metadata file {paths.metadata_path}: {e}. Removing it from disk and continue."
+                )
+                try:
+                    paths.metadata_path.unlink()
+                except Exception as e:
+                    logger.warning(f"Could not remove corrupted metadata file {paths.metadata_path}: {e}")
+                return None
+
+            try:
+                # check if the file exists and hasn't been modified since the metadata was saved
+                stat = paths.file_path.stat()
+                if (
+                    stat.st_mtime - 1 <= metadata.timestamp
+                ):  # allow 1s difference as stat.st_mtime might not be precise
+                    return metadata
+                logger.info(f"Ignored metadata for '{filename}' (outdated). Will re-compute hash.")
+            except FileNotFoundError:
+                # file does not exist => metadata is outdated
+                return None
+    return None
+
+
+def read_upload_metadata(local_dir: Path, filename: str) -> LocalUploadFileMetadata:
+    """Read metadata about a file in the local directory related to an upload process.
+
+    TODO: factorize logic with `read_download_metadata`.
+
+    Args:
+        local_dir (`Path`):
+            Path to the local directory in which files are downloaded.
+        filename (`str`):
+            Path of the file in the repo.
+
+    Return:
+        `[LocalUploadFileMetadata]` or `None`: the metadata if it exists, `None` otherwise.
+    """
+    paths = get_local_upload_paths(local_dir, filename)
+    with WeakFileLock(paths.lock_path):
+        if paths.metadata_path.exists():
+            try:
+                with paths.metadata_path.open() as f:
+                    timestamp = float(f.readline().strip())
+
+                    size = int(f.readline().strip())  # never None
+
+                    _should_ignore = f.readline().strip()
+                    should_ignore = None if _should_ignore == "" else bool(int(_should_ignore))
+
+                    _sha256 = f.readline().strip()
+                    sha256 = None if _sha256 == "" else _sha256
+
+                    _upload_mode = f.readline().strip()
+                    upload_mode = None if _upload_mode == "" else _upload_mode
+                    if upload_mode not in (None, "regular", "lfs"):
+                        raise ValueError(f"Invalid upload mode in metadata {paths.path_in_repo}: {upload_mode}")
+
+                    _remote_oid = f.readline().strip()
+                    remote_oid = None if _remote_oid == "" else _remote_oid
+
+                    is_uploaded = bool(int(f.readline().strip()))
+                    is_committed = bool(int(f.readline().strip()))
+
+                    metadata = LocalUploadFileMetadata(
+                        timestamp=timestamp,
+                        size=size,
+                        should_ignore=should_ignore,
+                        sha256=sha256,
+                        upload_mode=upload_mode,
+                        remote_oid=remote_oid,
+                        is_uploaded=is_uploaded,
+                        is_committed=is_committed,
+                    )
+            except Exception as e:
+                # remove the metadata file if it is corrupted / not the right format
+                logger.warning(
+                    f"Invalid metadata file {paths.metadata_path}: {e}. Removing it from disk and continue."
+                )
+                try:
+                    paths.metadata_path.unlink()
+                except Exception as e:
+                    logger.warning(f"Could not remove corrupted metadata file {paths.metadata_path}: {e}")
+
+                # corrupted metadata => we don't know anything expect its size
+                return LocalUploadFileMetadata(size=paths.file_path.stat().st_size)
+
+            # TODO: can we do better?
+            if (
+                metadata.timestamp is not None
+                and metadata.is_uploaded  # file was uploaded
+                and not metadata.is_committed  # but not committed
+                and time.time() - metadata.timestamp > 20 * 3600  # and it's been more than 20 hours
+            ):  # => we consider it as garbage-collected by S3
+                metadata.is_uploaded = False
+
+            # check if the file exists and hasn't been modified since the metadata was saved
+            try:
+                if metadata.timestamp is not None and paths.file_path.stat().st_mtime <= metadata.timestamp:
+                    return metadata
+                logger.info(f"Ignored metadata for '{filename}' (outdated). Will re-compute hash.")
+            except FileNotFoundError:
+                # file does not exist => metadata is outdated
+                pass
+
+    # empty metadata => we don't know anything expect its size
+    return LocalUploadFileMetadata(size=paths.file_path.stat().st_size)
+
+
+def write_download_metadata(local_dir: Path, filename: str, commit_hash: str, etag: str) -> None:
+    """Write metadata about a file in the local directory related to a download process.
+
+    Args:
+        local_dir (`Path`):
+            Path to the local directory in which files are downloaded.
+    """
+    paths = get_local_download_paths(local_dir, filename)
+    with WeakFileLock(paths.lock_path):
+        with paths.metadata_path.open("w") as f:
+            f.write(f"{commit_hash}\n{etag}\n{time.time()}\n")
+
+
+def _huggingface_dir(local_dir: Path) -> Path:
+    """Return the path to the `.cache/huggingface` directory in a local directory."""
+    # Wrap in lru_cache to avoid overwriting the .gitignore file if called multiple times
+    path = local_dir / ".cache" / "huggingface"
+    path.mkdir(exist_ok=True, parents=True)
+
+    # Create a CACHEDIR.TAG so backup tools can skip this directory.
+    _create_cachedir_tag(path)
+
+    # Create a .gitignore file in the .cache/huggingface directory if it doesn't exist
+    # Should be thread-safe enough like this.
+    gitignore = path / ".gitignore"
+    gitignore_lock = path / ".gitignore.lock"
+    if not gitignore.exists():
+        try:
+            with WeakFileLock(gitignore_lock, timeout=0.1):
+                gitignore.write_text("*")
+        except IndexError:
+            pass
+        except OSError:  # TimeoutError, FileNotFoundError, PermissionError, etc.
+            pass
+        try:
+            gitignore_lock.unlink()
+        except OSError:
+            pass
+    return path
+
+
+def _create_cachedir_tag(cache_dir: Path) -> None:
+    """Create a CACHEDIR.TAG file in ``cache_dir`` if one does not already exist.
+
+    The tag follows the `Cache Directory Tagging Standard <http://www.brynosaurus.com/cachedir/>`_
+    so that backup tools can recognize and skip cache directories.
+    """
+    tag_path = cache_dir / "CACHEDIR.TAG"
+    if not tag_path.exists():
+        try:
+            tag_path.write_text(CACHEDIR_TAG_CONTENT)
+        except OSError:
+            pass
+
+
+def _short_hash(filename: str) -> str:
+    return base64.urlsafe_b64encode(hashlib.sha1(filename.encode()).digest()).decode()

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_login.py

@@ -0,0 +1,559 @@
+# 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 methods to log in to the Hub."""
+
+import html
+import os
+import subprocess
+import sys
+import time
+from datetime import datetime
+from getpass import getpass
+from pathlib import Path
+
+from . import constants
+from .errors import DeviceCodeError
+from .utils import (
+    ANSI,
+    get_token,
+    is_google_colab,
+    is_notebook,
+    list_credential_helpers,
+    logging,
+    run_subprocess,
+    select_choice,
+    set_git_credential,
+    tabulate,
+    unset_git_credential,
+)
+from .utils._auth import (
+    _get_token_by_name,
+    _get_token_from_environment,
+    _get_token_from_file,
+    _get_token_from_google_colab,
+    _read_stored_tokens_full,
+    _save_stored_tokens_full,
+    _save_token,
+    _write_secret,
+    get_stored_tokens,
+)
+from .utils._oauth_device import OAuthTokenResponse, poll_device_token, request_device_code
+
+
+logger = logging.get_logger(__name__)
+
+
+def login(
+    token: str | None = None,
+    *,
+    add_to_git_credential: bool = False,
+    skip_if_logged_in: bool = True,
+) -> None:
+    """Login the machine to access the Hub.
+
+    The `token` is persisted in cache and set as a git credential. Once done, the machine
+    is logged in and the access token will be available across all `huggingface_hub`
+    components. If `token` is not provided, a browser-based OAuth flow is used to
+    authenticate: open a URL, enter a short code, and the token is retrieved and saved.
+    In a terminal, you can also choose to paste an existing access token instead.
+
+    To log in from outside of a script, one can also use `hf auth login` which is
+    a cli command that wraps [`login`].
+
+    > [!TIP]
+    > When the token is not passed, [`login`] will automatically detect if the script runs
+    > in a notebook or not. However, this detection might not be accurate due to the
+    > variety of notebooks that exists nowadays. If that is the case, you can always force
+    > the UI by using [`notebook_login`] or [`interpreter_login`].
+
+    Args:
+        token (`str`, *optional*):
+            User access token to generate from https://huggingface.co/settings/token.
+        add_to_git_credential (`bool`, defaults to `False`):
+            If `True`, token will be set as git credential. If no git credential helper
+            is configured, a warning will be displayed to the user. Only used when `token`
+            is provided; ignored by the browser-based flow.
+        skip_if_logged_in (`bool`, defaults to `True`):
+            If `True`, do not prompt for token if user is already logged in.
+            Set to `False` to force re-login. In CLI, use `--force` instead.
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If an organization token is passed. Only personal account tokens are valid
+            to log in.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If token is invalid.
+        [`DeviceCodeError`]
+            If the browser-based login fails (authorization denied, code expired, ...).
+    """
+    if token is not None:
+        if not add_to_git_credential:
+            logger.info(
+                "The token has not been saved to the git credentials helper. Pass "
+                "`add_to_git_credential=True` in this function directly or "
+                "`--add-to-git-credential` if using via `hf`CLI if "
+                "you want to set the git credential as well."
+            )
+        _validate_and_save_token(token, add_to_git_credential=add_to_git_credential)
+        return
+    if add_to_git_credential:
+        logger.warning(
+            "`add_to_git_credential=True` is only supported when a token is passed directly. "
+            "It is ignored by the browser-based login."
+        )
+    if is_notebook():
+        notebook_login(skip_if_logged_in=skip_if_logged_in)
+    else:
+        interpreter_login(skip_if_logged_in=skip_if_logged_in)
+
+
+def logout(token_name: str | None = None) -> None:
+    """Logout the machine from the Hub.
+
+    Token is deleted from the machine and removed from git credential.
+
+    Args:
+        token_name (`str`, *optional*):
+            Name of the access token to logout from. If `None`, will log out from all saved access tokens.
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError):
+            If the access token name is not found.
+    """
+    if get_token() is None and not get_stored_tokens():  # No active token and no saved access tokens
+        logger.warning("Not logged in!")
+        return
+    if not token_name:
+        # Delete all saved access tokens and token
+        for file_path in (constants.HF_TOKEN_PATH, constants.HF_STORED_TOKENS_PATH):
+            try:
+                Path(file_path).unlink()
+            except FileNotFoundError:
+                pass
+        logger.info("Successfully logged out from all access tokens.")
+    else:
+        _logout_from_token(token_name)
+        logger.info(f"Successfully logged out from access token: {token_name}.")
+
+    unset_git_credential()
+
+    # Check if still logged in
+    if _get_token_from_google_colab() is not None:
+        raise OSError(
+            "You are automatically logged in using a Google Colab secret.\n"
+            "To log out, you must unset the `HF_TOKEN` secret in your Colab settings."
+        )
+    if _get_token_from_environment() is not None:
+        raise OSError(
+            "Token has been deleted from your machine but you are still logged in.\n"
+            "To log out, you must clear out both `HF_TOKEN` and `HUGGING_FACE_HUB_TOKEN` environment variables."
+        )
+
+
+def auth_switch(token_name: str, add_to_git_credential: bool = False) -> None:
+    """Switch to a different access token.
+
+    Args:
+        token_name (`str`):
+            Name of the access token to switch to.
+        add_to_git_credential (`bool`, defaults to `False`):
+            If `True`, token will be set as git credential. If no git credential helper
+            is configured, a warning will be displayed to the user. If `token` is `None`,
+            the value of `add_to_git_credential` is ignored and will be prompted again
+            to the end user.
+
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError):
+            If the access token name is not found.
+    """
+    token = _get_token_by_name(token_name)
+    if not token:
+        raise ValueError(f"Access token {token_name} not found in {constants.HF_STORED_TOKENS_PATH}")
+    # Write token to HF_TOKEN_PATH
+    _set_active_token(token_name, add_to_git_credential)
+    logger.info(f"The current active token is: {token_name}")
+    token_from_environment = _get_token_from_environment()
+    if token_from_environment is not None and token_from_environment != token:
+        logger.warning(
+            "The environment variable `HF_TOKEN` is set and will override the access token you've just switched to."
+        )
+
+
+def auth_list() -> None:
+    """List all stored access tokens."""
+    # Resolve the current token before reading the file: `get_token()` may refresh an OAuth
+    # token and rewrite the stored tokens on the way.
+    current_token = get_token()
+    stored_tokens = _read_stored_tokens_full()
+
+    if not stored_tokens:
+        if _get_token_from_environment():
+            logger.info("No stored access tokens found.")
+            logger.warning("Note: Environment variable `HF_TOKEN` is set and is the current active token.")
+        else:
+            logger.info("No access tokens found.")
+        return
+    show_expires = any("expires_at" in fields for fields in stored_tokens.values())
+    headers = [" ", "name", "token"] + (["expires"] if show_expires else [])
+
+    current_token_name = None
+    rows: list[list[str | int]] = []
+    for token_name, fields in stored_tokens.items():
+        token = fields.get("hf_token", "<not set>")
+        if token == current_token:
+            current_token_name = token_name
+        masked_token = f"{token[:3]}****{token[-4:]}" if token != "<not set>" else token
+        row: list[str | int] = ["*" if token == current_token else "", token_name, masked_token]
+        if show_expires:
+            row.append(_format_expiration(fields.get("expires_at")))
+        rows.append(row)
+    print(tabulate(rows, headers=headers))
+
+    if _get_token_from_environment():
+        logger.warning(
+            "\nNote: Environment variable `HF_TOKEN` is set and is the current active token independently from the stored tokens listed above."
+        )
+    elif current_token_name is None:
+        logger.warning(
+            "\nNote: No active token is set and no environment variable `HF_TOKEN` is found. Use `hf auth login` to log in."
+        )
+
+
+###
+# Device Code OAuth login (RFC 8628)
+###
+
+
+def _device_code_login() -> None:
+    """Run the Device Code OAuth flow: request a code, prompt the user to authorize it in a browser,
+    poll for the token and save it."""
+    device_info = request_device_code()
+
+    # The complete URI has the code pre-filled when the server supports it.
+    print(f"\n    Open this URL in your browser:\n        {device_info['verification_uri_complete']}\n")
+    print(f"    And enter the code: {device_info['user_code']}\n")
+
+    print("    Waiting for authorization", end="", flush=True)
+    try:
+        response = poll_device_token(device_info, on_pending=lambda: print(".", end="", flush=True))
+    finally:
+        print()  # newline after the progress dots, also on failure
+
+    _save_oauth_token(response)
+
+
+def _save_oauth_token(response: OAuthTokenResponse) -> tuple[str, str]:
+    """Validate and persist a token response from the device code flow, including refresh metadata."""
+    expires_in = response.get("expires_in")
+    token_name, username = _validate_and_save_token(
+        response["access_token"],
+        add_to_git_credential=False,
+        refresh_token=response.get("refresh_token"),
+        expires_at=int(time.time()) + int(expires_in) if expires_in else None,
+    )
+    if note := _expiration_note(response):
+        logger.info(f"Note: {note}")
+    return token_name, username
+
+
+def _expiration_note(response: OAuthTokenResponse) -> str | None:
+    """Human-readable note about the lifetime of a freshly obtained OAuth token, if known."""
+    expires_in = response.get("expires_in")
+    if not expires_in:
+        return None
+    if response.get("refresh_token"):
+        return "This token will be refreshed automatically when it expires."
+    days = max(1, int(expires_in) // 86400)
+    return f"This token expires in {days} days. Log in again to renew it."
+
+
+###
+# Interpreter-based login (text)
+###
+
+
+def interpreter_login(*, skip_if_logged_in: bool = True) -> None:
+    """
+    Displays a prompt to log in to the HF website and store the token.
+
+    This is equivalent to [`login`] without passing a token when not run in a notebook.
+    [`interpreter_login`] is useful if you want to force the use of the terminal prompt
+    instead of a notebook flow.
+
+    For more details, see [`login`].
+
+    Args:
+        skip_if_logged_in (`bool`, defaults to `True`):
+            If `True`, do not prompt for token if user is already logged in.
+            Set to `False` to force re-login. In CLI, use `--force` instead.
+    """
+    if skip_if_logged_in and get_token() is not None:
+        logger.info("User is already logged in. Use `hf auth login --force` to force re-login.")
+        return
+
+    if get_token() is not None:
+        logger.info("Note: a token is already saved on this machine. Logging in again will replace the active token.")
+
+    if _prompt_login_method() == "token":
+        _paste_token_login()
+    else:
+        _device_code_login()
+
+
+def _prompt_login_method() -> str:
+    """Ask the user how to log in: "browser" (default) or "token". Never prompts without a TTY."""
+    if sys.stdin is None or not sys.stdin.isatty():
+        return "browser"
+    choice = select_choice("How would you like to log in?", ["Log in with your browser", "Paste an access token"])
+    return "browser" if choice == 0 else "token"
+
+
+def _paste_token_login() -> None:
+    logger.info(
+        "    To log in, `huggingface_hub` requires a token generated from https://huggingface.co/settings/tokens ."
+    )
+    if os.name == "nt":
+        logger.info("Token can be pasted using 'Right-Click'.")
+    token = getpass("Enter your token (input will not be visible): ")
+    _validate_and_save_token(token=token, add_to_git_credential=False)
+
+
+###
+# Notebook-based login
+###
+
+
+def notebook_login(*, skip_if_logged_in: bool = True) -> None:
+    """
+    Displays a prompt to log in to the HF website and store the token.
+
+    This is equivalent to [`login`] without passing a token when run in a notebook.
+    [`notebook_login`] is useful if you want to force the use of the notebook flow
+    instead of a prompt in the terminal.
+
+    For more details, see [`login`].
+
+    Args:
+        skip_if_logged_in (`bool`, defaults to `True`):
+            If `True`, do not prompt for token if user is already logged in.
+            Set to `False` to force re-login. In CLI, use `--force` instead.
+    """
+    if skip_if_logged_in and get_token() is not None:
+        logger.info("User is already logged in. Use `hf auth login --force` to force re-login.")
+        return
+
+    try:
+        from IPython.display import HTML, display  # type: ignore
+    except ImportError:
+        # Not in a notebook environment: fall back to the terminal flow
+        interpreter_login(skip_if_logged_in=False)
+        return
+
+    device_info = request_device_code()
+    # Escape server-provided values: they end up in raw notebook HTML.
+    verification_uri = html.escape(device_info["verification_uri"])
+    verification_uri_complete = html.escape(device_info["verification_uri_complete"])
+
+    display(
+        HTML(
+            '<center><img src="https://huggingface.co/front/assets/huggingface_logo-noborder.svg"'
+            ' width="100" alt="Hugging Face"><br><br>'
+            "<p>To log in, open this URL and enter the code:</p>"
+            f'<p><a href="{verification_uri_complete}" target="_blank"><b>{verification_uri}</b></a></p>'
+            '<p style="font-size: 1.6em; letter-spacing: 0.3em; font-family: monospace;">'
+            f"<b>{html.escape(device_info['user_code'])}</b></p></center>"
+        )
+    )
+    display(HTML("<center><i>Waiting for authorization...</i></center>"))
+    try:
+        response = poll_device_token(device_info)
+    except DeviceCodeError as e:
+        display(HTML(f"<center><b style='color: red;'>Login failed: {html.escape(str(e))}</b></center>"))
+        return
+
+    try:
+        token_name, username = _save_oauth_token(response)
+    except Exception as error:
+        display(HTML(f"<center><b style='color: red;'>{html.escape(str(error))}</b></center>"))
+        return
+
+    message = f"Login successful. Logged in as <b>{html.escape(username)}</b> (token: <code>{html.escape(token_name)}</code>)."
+    if note := _expiration_note(response):
+        message += f"<br>{html.escape(note)}"
+    display(HTML(f"<center>{message}</center>"))
+
+
+###
+# Login private helpers
+###
+
+
+def _validate_and_save_token(
+    token: str,
+    add_to_git_credential: bool,
+    refresh_token: str | None = None,
+    expires_at: int | None = None,
+) -> tuple[str, str]:
+    """Validate a token against the Hub, save it to the stored tokens file and set it as active.
+
+    The token is stored under its `displayName` from the whoami response, or `oauth-{username}`
+    for OAuth tokens (which have no display name).
+
+    Args:
+        token (`str`):
+            The access token.
+        add_to_git_credential (`bool`):
+            Whether to save the token to the git credential helpers.
+        refresh_token (`str`, *optional*):
+            OAuth refresh token to persist alongside the access token.
+        expires_at (`int`, *optional*):
+            Unix timestamp at which the access token expires.
+
+    Returns:
+        `tuple[str, str]`: The token name and the username.
+    """
+    from .hf_api import whoami  # avoid circular import
+
+    if token.startswith("api_org"):
+        raise ValueError("You must use your personal account token, not an organization token.")
+
+    token_info = whoami(token)
+    username = token_info["name"]
+
+    access_token_info = (token_info.get("auth") or {}).get("accessToken") or {}
+    if role := access_token_info.get("role"):
+        logger.info(f"Token is valid (permission: {role}).")
+    else:
+        logger.info("Token is valid.")
+
+    token_name = access_token_info.get("displayName") or f"oauth-{username}"
+
+    # Store token locally
+    _save_token(token=token, token_name=token_name, refresh_token=refresh_token, expires_at=expires_at)
+    # Set active token
+    _set_active_token(token_name=token_name, add_to_git_credential=add_to_git_credential)
+    logger.info("Login successful.")
+    if _get_token_from_environment():
+        logger.warning(
+            "Note: Environment variable`HF_TOKEN` is set and is the current active token independently from the token you've just configured."
+        )
+    else:
+        logger.info(f"The current active token is: `{token_name}`")
+    return token_name, username
+
+
+def _logout_from_token(token_name: str) -> None:
+    """Logout from a specific access token.
+
+    Args:
+        token_name (`str`):
+            The name of the access token to logout from.
+    """
+    stored_tokens = _read_stored_tokens_full()
+    # If there is no access tokens saved or the access token name is not found, do nothing
+    if token_name not in stored_tokens:
+        return
+
+    fields = stored_tokens.pop(token_name)
+    _save_stored_tokens_full(stored_tokens)
+
+    if fields.get("hf_token") == _get_token_from_file():
+        logger.warning(f"Active token '{token_name}' has been deleted.")
+        Path(constants.HF_TOKEN_PATH).unlink(missing_ok=True)
+
+
+def _format_expiration(expires_at: str | None) -> str:
+    """Format an `expires_at` unix timestamp for display in `auth list`."""
+    if not expires_at:
+        return ""
+    try:
+        timestamp = int(expires_at)
+    except ValueError:
+        return ""
+    date_str = datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d")
+    return f"{date_str} (expired)" if timestamp < time.time() else date_str
+
+
+def _set_active_token(
+    token_name: str,
+    add_to_git_credential: bool,
+) -> None:
+    """Set the active access token.
+
+    Args:
+        token_name (`str`):
+            The name of the token to set as active.
+    """
+    token = _get_token_by_name(token_name)
+    if not token:
+        raise ValueError(f"Token {token_name} not found in {constants.HF_STORED_TOKENS_PATH}")
+    if add_to_git_credential:
+        if _is_git_credential_helper_configured():
+            set_git_credential(token)
+            logger.info(
+                "Your token has been saved in your configured git credential helpers"
+                + f" ({','.join(list_credential_helpers())})."
+            )
+        else:
+            logger.warning("Token has not been saved to git credential helper.")
+    # Write token to HF_TOKEN_PATH
+    _write_secret(Path(constants.HF_TOKEN_PATH), token)
+    logger.info(f"Your token has been saved to {constants.HF_TOKEN_PATH}")
+
+
+def _is_git_credential_helper_configured() -> bool:
+    """Check if a git credential helper is configured.
+
+    Warns user if not the case (except for Google Colab where "store" is set by default
+    by `huggingface_hub`).
+    """
+    helpers = list_credential_helpers()
+    if len(helpers) > 0:
+        return True  # Do not warn: at least 1 helper is set
+
+    # Only in Google Colab to avoid the warning message
+    # See https://github.com/huggingface/huggingface_hub/issues/1043#issuecomment-1247010710
+    if is_google_colab():
+        _set_store_as_git_credential_helper_globally()
+        return True  # Do not warn: "store" is used by default in Google Colab
+
+    # Otherwise, warn user
+    print(
+        ANSI.red(
+            "Cannot authenticate through git-credential as no helper is defined on your"
+            " machine.\nYou might have to re-authenticate when pushing to the Hugging"
+            " Face Hub.\nRun the following command in your terminal in case you want to"
+            " set the 'store' credential helper as default.\n\ngit config --global"
+            " credential.helper store\n\nRead"
+            " https://git-scm.com/book/en/v2/Git-Tools-Credential-Storage for more"
+            " details."
+        )
+    )
+    return False
+
+
+def _set_store_as_git_credential_helper_globally() -> None:
+    """Set globally the credential.helper to `store`.
+
+    To be used only in Google Colab as we assume the user doesn't care about the git
+    credential config. It is the only particular case where we don't want to display the
+    warning message in [`notebook_login()`].
+
+    Related:
+    - https://github.com/huggingface/huggingface_hub/issues/1043
+    - https://github.com/huggingface/huggingface_hub/issues/1051
+    - https://git-scm.com/docs/git-credential-store
+    """
+    try:
+        run_subprocess("git config --global credential.helper store")
+    except subprocess.CalledProcessError as exc:
+        raise OSError(exc.stderr)

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_oauth.py

@@ -0,0 +1,460 @@
+import datetime
+import hashlib
+import logging
+import os
+import time
+import urllib.parse
+import warnings
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+from . import constants
+from .hf_api import whoami
+from .utils import experimental, get_token
+
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    import fastapi
+
+
+@dataclass
+class OAuthOrgInfo:
+    """
+    Information about an organization linked to a user logged in with OAuth.
+
+    Attributes:
+        sub (`str`):
+            Unique identifier for the org. OpenID Connect field.
+        name (`str`):
+            The org's full name. OpenID Connect field.
+        preferred_username (`str`):
+            The org's username. OpenID Connect field.
+        picture (`str`):
+            The org's profile picture URL. OpenID Connect field.
+        plan (`str`, *optional*):
+            The org's plan (e.g., "enterprise", "team"). Hugging Face field.
+        can_pay (`Optional[bool]`, *optional*):
+            Whether the org has a payment method set up. Hugging Face field.
+        role_in_org (`Optional[str]`, *optional*):
+            The user's role in the org. Hugging Face field.
+        security_restrictions (`Optional[list[Literal["ip", "token-policy", "mfa", "sso"]]]`, *optional*):
+            Array of security restrictions that the user hasn't completed for this org. Possible values: "ip", "token-policy", "mfa", "sso". Hugging Face field.
+    """
+
+    sub: str
+    name: str
+    preferred_username: str
+    picture: str
+    plan: str | None = None
+    can_pay: bool | None = None
+    role_in_org: str | None = None
+    security_restrictions: list[Literal["ip", "token-policy", "mfa", "sso"]] | None = None
+
+
+@dataclass
+class OAuthUserInfo:
+    """
+    Information about a user logged in with OAuth.
+
+    Attributes:
+        sub (`str`):
+            Unique identifier for the user, even in case of rename. OpenID Connect field.
+        name (`str`):
+            The user's full name. OpenID Connect field.
+        preferred_username (`str`):
+            The user's username. OpenID Connect field.
+        email_verified (`Optional[bool]`, *optional*):
+            Indicates if the user's email is verified. OpenID Connect field.
+        email (`Optional[str]`, *optional*):
+            The user's email address. OpenID Connect field.
+        picture (`str`):
+            The user's profile picture URL. OpenID Connect field.
+        profile (`str`):
+            The user's profile URL. OpenID Connect field.
+        website (`Optional[str]`, *optional*):
+            The user's website URL. OpenID Connect field.
+        is_pro (`bool`):
+            Whether the user is a pro user. Hugging Face field.
+        can_pay (`Optional[bool]`, *optional*):
+            Whether the user has a payment method set up. Hugging Face field.
+        orgs (`Optional[list[OrgInfo]]`, *optional*):
+            List of organizations the user is part of. Hugging Face field.
+    """
+
+    sub: str
+    name: str
+    preferred_username: str
+    email_verified: bool | None
+    email: str | None
+    picture: str
+    profile: str
+    website: str | None
+    is_pro: bool
+    can_pay: bool | None
+    orgs: list[OAuthOrgInfo] | None
+
+
+@dataclass
+class OAuthInfo:
+    """
+    Information about the OAuth login.
+
+    Attributes:
+        access_token (`str`):
+            The access token.
+        access_token_expires_at (`datetime.datetime`):
+            The expiration date of the access token.
+        user_info ([`OAuthUserInfo`]):
+            The user information.
+        state (`str`, *optional*):
+            State passed to the OAuth provider in the original request to the OAuth provider.
+        scope (`str`):
+            Granted scope.
+    """
+
+    access_token: str
+    access_token_expires_at: datetime.datetime
+    user_info: OAuthUserInfo
+    state: str | None
+    scope: str
+
+
+@experimental
+def attach_huggingface_oauth(app: "fastapi.FastAPI", route_prefix: str = "/"):
+    """
+    Add OAuth endpoints to a FastAPI app to enable OAuth login with Hugging Face.
+
+    How to use:
+    - Call this method on your FastAPI app to add the OAuth endpoints.
+    - Inside your route handlers, call `parse_huggingface_oauth(request)` to retrieve the OAuth info.
+    - If user is logged in, an [`OAuthInfo`] object is returned with the user's info. If not, `None` is returned.
+    - In your app, make sure to add links to `/oauth/huggingface/login` and `/oauth/huggingface/logout` for the user to log in and out.
+
+    Example:
+    ```py
+    from huggingface_hub import attach_huggingface_oauth, parse_huggingface_oauth
+
+    # Create a FastAPI app
+    app = FastAPI()
+
+    # Add OAuth endpoints to the FastAPI app
+    attach_huggingface_oauth(app)
+
+    # Add a route that greets the user if they are logged in
+    @app.get("/")
+    def greet_json(request: Request):
+        # Retrieve the OAuth info from the request
+        oauth_info = parse_huggingface_oauth(request)  # e.g. OAuthInfo dataclass
+        if oauth_info is None:
+            return {"msg": "Not logged in!"}
+        return {"msg": f"Hello, {oauth_info.user_info.preferred_username}!"}
+    ```
+    """
+    # TODO: handle generic case (handling OAuth in a non-Space environment with custom dev values) (low priority)
+
+    # Add SessionMiddleware to the FastAPI app to store the OAuth info in the session.
+    # Session Middleware requires a secret key to sign the cookies. Let's use a hash
+    # of the OAuth secret key to make it unique to the Space + updated in case OAuth
+    # config gets updated. When ran locally, we use an empty string as a secret key.
+    try:
+        from starlette.middleware.sessions import SessionMiddleware
+    except ImportError as e:
+        raise ImportError(
+            "Cannot initialize OAuth to due a missing library. Please run `pip install huggingface_hub[oauth]` or add "
+            "`huggingface_hub[oauth]` to your requirements.txt file in order to install the required dependencies."
+        ) from e
+    session_secret = (constants.OAUTH_CLIENT_SECRET or "") + "-v1"
+    app.add_middleware(
+        SessionMiddleware,  # type: ignore
+        secret_key=hashlib.sha256(session_secret.encode()).hexdigest(),
+        same_site="none",
+        https_only=True,
+    )  # type: ignore
+
+    # Add OAuth endpoints to the FastAPI app:
+    #   - {route_prefix}/oauth/huggingface/login
+    #   - {route_prefix}/oauth/huggingface/callback
+    #   - {route_prefix}/oauth/huggingface/logout
+    # If the app is running in a Space, OAuth is enabled normally.
+    # Otherwise, we mock the endpoints to make the user log in with a fake user profile - without any calls to hf.co.
+    route_prefix = route_prefix.strip("/")
+    if os.getenv("SPACE_ID") is not None:
+        logger.info("OAuth is enabled in the Space. Adding OAuth routes.")
+        _add_oauth_routes(app, route_prefix=route_prefix)
+    else:
+        logger.info("App is not running in a Space. Adding mocked OAuth routes.")
+        _add_mocked_oauth_routes(app, route_prefix=route_prefix)
+
+
+def parse_huggingface_oauth(request: "fastapi.Request") -> OAuthInfo | None:
+    """
+    Returns the information from a logged-in user as a [`OAuthInfo`] object.
+
+    For flexibility and future-proofing, this method is very lax in its parsing and does not raise errors.
+    Missing fields are set to `None` without a warning.
+
+    Return `None`, if the user is not logged in (no info in session cookie).
+
+    See [`attach_huggingface_oauth`] for an example on how to use this method.
+    """
+    if "oauth_info" not in request.session:
+        logger.debug("No OAuth info in session.")
+        return None
+
+    logger.debug("Parsing OAuth info from session.")
+    oauth_data = request.session["oauth_info"]
+    user_data = oauth_data.get("userinfo", {})
+    orgs_data = user_data.get("orgs", [])
+
+    orgs = (
+        [
+            OAuthOrgInfo(
+                sub=org.get("sub"),
+                name=org.get("name"),
+                preferred_username=org.get("preferred_username"),
+                picture=org.get("picture"),
+                plan=org.get("plan"),
+                can_pay=org.get("canPay"),
+                role_in_org=org.get("roleInOrg"),
+                security_restrictions=org.get("securityRestrictions"),
+            )
+            for org in orgs_data
+        ]
+        if orgs_data
+        else None
+    )
+
+    user_info = OAuthUserInfo(
+        sub=user_data.get("sub"),
+        name=user_data.get("name"),
+        preferred_username=user_data.get("preferred_username"),
+        email_verified=user_data.get("email_verified"),
+        email=user_data.get("email"),
+        picture=user_data.get("picture"),
+        profile=user_data.get("profile"),
+        website=user_data.get("website"),
+        is_pro=user_data.get("isPro"),
+        can_pay=user_data.get("canPay"),
+        orgs=orgs,
+    )
+
+    return OAuthInfo(
+        access_token=oauth_data.get("access_token"),
+        access_token_expires_at=datetime.datetime.fromtimestamp(oauth_data.get("expires_at")),
+        user_info=user_info,
+        state=oauth_data.get("state"),
+        scope=oauth_data.get("scope"),
+    )
+
+
+def _add_oauth_routes(app: "fastapi.FastAPI", route_prefix: str) -> None:
+    """Add OAuth routes to the FastAPI app (login, callback handler and logout)."""
+    try:
+        import fastapi
+        from authlib.integrations.base_client.errors import MismatchingStateError
+        from authlib.integrations.starlette_client import OAuth
+        from fastapi.responses import RedirectResponse
+    except ImportError as e:
+        raise ImportError(
+            "Cannot initialize OAuth to due a missing library. Please run `pip install huggingface_hub[oauth]` or add "
+            "`huggingface_hub[oauth]` to your requirements.txt file."
+        ) from e
+
+    # Check environment variables
+    msg = (
+        "OAuth is required but '{}' environment variable is not set. Make sure you've enabled OAuth in your Space by"
+        " setting `hf_oauth: true` in the Space metadata."
+    )
+    if constants.OAUTH_CLIENT_ID is None:
+        raise ValueError(msg.format("OAUTH_CLIENT_ID"))
+    if constants.OAUTH_CLIENT_SECRET is None:
+        raise ValueError(msg.format("OAUTH_CLIENT_SECRET"))
+    if constants.OAUTH_SCOPES is None:
+        raise ValueError(msg.format("OAUTH_SCOPES"))
+    if constants.OPENID_PROVIDER_URL is None:
+        raise ValueError(msg.format("OPENID_PROVIDER_URL"))
+
+    # Register OAuth server
+    oauth = OAuth()
+    oauth.register(
+        name="huggingface",
+        client_id=constants.OAUTH_CLIENT_ID,
+        client_secret=constants.OAUTH_CLIENT_SECRET,
+        client_kwargs={"scope": constants.OAUTH_SCOPES},
+        server_metadata_url=constants.OPENID_PROVIDER_URL + "/.well-known/openid-configuration",
+    )
+
+    login_uri, callback_uri, logout_uri = _get_oauth_uris(route_prefix)
+
+    # Register OAuth endpoints
+    @app.get(login_uri)
+    async def oauth_login(request: fastapi.Request) -> RedirectResponse:
+        """Endpoint that redirects to HF OAuth page."""
+        redirect_uri = _generate_redirect_uri(request)
+        return await oauth.huggingface.authorize_redirect(request, redirect_uri)  # type: ignore
+
+    @app.get(callback_uri)
+    async def oauth_redirect_callback(request: fastapi.Request) -> RedirectResponse:
+        """Endpoint that handles the OAuth callback."""
+        try:
+            oauth_info = await oauth.huggingface.authorize_access_token(request)  # type: ignore
+        except MismatchingStateError:
+            # Parse query params
+            nb_redirects = int(request.query_params.get("_nb_redirects", 0))
+            target_url = request.query_params.get("_target_url")
+
+            # Build redirect URI with the same query params as before and bump nb_redirects count
+            query_params: dict[str, int | str] = {"_nb_redirects": nb_redirects + 1}
+            if target_url:
+                query_params["_target_url"] = target_url
+
+            redirect_uri = f"{login_uri}?{urllib.parse.urlencode(query_params)}"
+
+            # If the user is redirected more than 3 times, it is very likely that the cookie is not working properly.
+            # (e.g. browser is blocking third-party cookies in iframe). In this case, redirect the user in the
+            # non-iframe view.
+            if nb_redirects > constants.OAUTH_MAX_REDIRECTS:
+                host = os.environ.get("SPACE_HOST")
+                if host is None:  # cannot happen in a Space
+                    raise RuntimeError(
+                        "App is not running in a Space (SPACE_HOST environment variable is not set). Cannot redirect to non-iframe view."
+                    ) from None
+                host_url = "https://" + host.rstrip("/")
+                return RedirectResponse(host_url + redirect_uri)
+
+            # Redirect the user to the login page again
+            return RedirectResponse(redirect_uri)
+
+        # OAuth login worked => store the user info in the session and redirect
+        logger.debug("Successfully logged in with OAuth. Storing user info in session.")
+        request.session["oauth_info"] = oauth_info
+        return RedirectResponse(_get_redirect_target(request))
+
+    @app.get(logout_uri)
+    async def oauth_logout(request: fastapi.Request) -> RedirectResponse:
+        """Endpoint that logs out the user (e.g. delete info from cookie session)."""
+        logger.debug("Logged out with OAuth. Removing user info from session.")
+        request.session.pop("oauth_info", None)
+        return RedirectResponse(_get_redirect_target(request))
+
+
+def _add_mocked_oauth_routes(app: "fastapi.FastAPI", route_prefix: str = "/") -> None:
+    """Add fake oauth routes if app is run locally and OAuth is enabled.
+
+    Using OAuth will have the same behavior as in a Space but instead of authenticating with HF, a mocked user profile
+    is added to the session.
+    """
+    try:
+        import fastapi
+        from fastapi.responses import RedirectResponse
+        from starlette.datastructures import URL
+    except ImportError as e:
+        raise ImportError(
+            "Cannot initialize OAuth to due a missing library. Please run `pip install huggingface_hub[oauth]` or add "
+            "`huggingface_hub[oauth]` to your requirements.txt file."
+        ) from e
+
+    warnings.warn(
+        "OAuth is not supported outside of a Space environment. To help you debug your app locally, the oauth endpoints"
+        " are mocked to return your profile and token. To make it work, your machine must be logged in to Huggingface."
+    )
+    mocked_oauth_info = _get_mocked_oauth_info()
+
+    login_uri, callback_uri, logout_uri = _get_oauth_uris(route_prefix)
+
+    # Define OAuth routes
+    @app.get(login_uri)
+    async def oauth_login(request: fastapi.Request) -> RedirectResponse:
+        """Fake endpoint that redirects to HF OAuth page."""
+        # Define target (where to redirect after login)
+        redirect_uri = _generate_redirect_uri(request)
+        return RedirectResponse(callback_uri + "?" + urllib.parse.urlencode({"_target_url": redirect_uri}))
+
+    @app.get(callback_uri)
+    async def oauth_redirect_callback(request: fastapi.Request) -> RedirectResponse:
+        """Endpoint that handles the OAuth callback."""
+        request.session["oauth_info"] = mocked_oauth_info
+        return RedirectResponse(_get_redirect_target(request))
+
+    @app.get(logout_uri)
+    async def oauth_logout(request: fastapi.Request) -> RedirectResponse:
+        """Endpoint that logs out the user (e.g. delete cookie session)."""
+        request.session.pop("oauth_info", None)
+        logout_url = URL("/").include_query_params(**request.query_params)
+        return RedirectResponse(url=logout_url, status_code=302)  # see https://github.com/gradio-app/gradio/pull/9659
+
+
+def _generate_redirect_uri(request: "fastapi.Request") -> str:
+    if "_target_url" in request.query_params:
+        # if `_target_url` already in query params => respect it
+        target = request.query_params["_target_url"]
+    else:
+        # otherwise => keep query params
+        target = "/?" + urllib.parse.urlencode(request.query_params)
+
+    redirect_uri = request.url_for("oauth_redirect_callback").include_query_params(_target_url=target)
+    redirect_uri_as_str = str(redirect_uri)
+    if redirect_uri.netloc.endswith(".hf.space"):
+        # In Space, FastAPI redirect as http but we want https
+        redirect_uri_as_str = redirect_uri_as_str.replace("http://", "https://")
+    return redirect_uri_as_str
+
+
+def _get_redirect_target(request: "fastapi.Request", default_target: str = "/") -> str:
+    return request.query_params.get("_target_url", default_target)
+
+
+def _get_mocked_oauth_info() -> dict:
+    token = get_token()
+    if token is None:
+        raise ValueError(
+            "Your machine must be logged in to HF to debug an OAuth app locally. Please"
+            " run `hf auth login` or set `HF_TOKEN` as environment variable "
+            "with one of your access token. You can generate a new token in your "
+            "settings page (https://huggingface.co/settings/tokens)."
+        )
+
+    user = whoami()
+    if user["type"] != "user":
+        raise ValueError(
+            "Your machine is not logged in with a personal account. Please use a "
+            "personal access token. You can generate a new token in your settings page"
+            " (https://huggingface.co/settings/tokens)."
+        )
+
+    return {
+        "access_token": token,
+        "token_type": "bearer",
+        "expires_in": 8 * 60 * 60,  # 8 hours
+        "id_token": "FOOBAR",
+        "scope": "openid profile",
+        "refresh_token": "hf_oauth__refresh_token",
+        "expires_at": int(time.time()) + 8 * 60 * 60,  # 8 hours
+        "userinfo": {
+            "sub": "0123456789",
+            "name": user["fullname"],
+            "preferred_username": user["name"],
+            "profile": f"https://huggingface.co/{user['name']}",
+            "picture": user["avatarUrl"],
+            "website": "",
+            "aud": "00000000-0000-0000-0000-000000000000",
+            "auth_time": 1691672844,
+            "nonce": "aaaaaaaaaaaaaaaaaaa",
+            "iat": 1691672844,
+            "exp": 1691676444,
+            "iss": "https://huggingface.co",
+        },
+    }
+
+
+def _get_oauth_uris(route_prefix: str = "/") -> tuple[str, str, str]:
+    route_prefix = route_prefix.strip("/")
+    if route_prefix:
+        route_prefix = f"/{route_prefix}"
+    return (
+        f"{route_prefix}/oauth/huggingface/login",
+        f"{route_prefix}/oauth/huggingface/callback",
+        f"{route_prefix}/oauth/huggingface/logout",
+    )

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_oidc.py

@@ -0,0 +1,163 @@
+# 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.
+"""Keyless CI/CD authentication via OIDC token exchange ("Trusted Publishers").
+
+A CI job proves its identity to the Hub with a short-lived OIDC id token minted by its CI
+provider (e.g. GitHub Actions), then exchanges it at ``POST {ENDPOINT}/oauth/token`` (RFC 8693)
+for a short-lived Hugging Face token — no long-lived ``HF_TOKEN`` secret to store.
+
+This module is self-contained: it only handles minting the provider id token and the exchange.
+It deliberately does not register a public API or a CLI verb; the integration point is the token
+resolution in ``utils/_auth.py`` (see ``_get_token_from_oidc``).
+
+Docs: https://huggingface.co/docs/hub/trusted-publishers
+"""
+
+import os
+from enum import Enum
+
+from . import constants
+from .errors import OIDCError
+from .utils import get_session, hf_raise_for_status
+
+
+# RFC 8693 token-exchange grant + id-token subject type (see trusted-publishers docs).
+_TOKEN_EXCHANGE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:token-exchange"
+_ID_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:id_token"
+
+
+class Provider(str, Enum):
+    """CI providers that can mint an OIDC id token natively. GitHub Actions only for now."""
+
+    GITHUB = "github"
+
+
+def detect_provider() -> Provider | None:
+    """Detect the CI provider able to mint an OIDC id token, or `None` if not in a supported CI."""
+    if os.environ.get("GITHUB_ACTIONS") == "true":
+        return Provider.GITHUB
+    return None
+
+
+def _get_github_oidc_token(audience: str) -> str:
+    """Mint an OIDC id token from the GitHub Actions runtime.
+
+    Relies on the `ACTIONS_ID_TOKEN_REQUEST_URL` / `ACTIONS_ID_TOKEN_REQUEST_TOKEN` env vars,
+    which GitHub only injects when the job declares `permissions: id-token: write`.
+    """
+    request_url = os.environ.get("ACTIONS_ID_TOKEN_REQUEST_URL")
+    request_token = os.environ.get("ACTIONS_ID_TOKEN_REQUEST_TOKEN")
+    if not request_url or not request_token:
+        raise OIDCError(
+            "Cannot request an OIDC id token from GitHub Actions. Make sure the workflow job sets "
+            "`permissions: id-token: write`. See "
+            "https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect"
+        )
+    response = get_session().get(
+        request_url,
+        params={"audience": audience},
+        headers={"Authorization": f"Bearer {request_token}"},
+    )
+    hf_raise_for_status(response)
+    return response.json()["value"]
+
+
+def get_oidc_token(*, provider: Provider | str | None = None, audience: str | None = None) -> str:
+    """Mint a raw OIDC id token (JWT) from the current CI provider.
+
+    Args:
+        provider (`str`, *optional*):
+            CI provider to use. Auto-detected from the environment when omitted.
+        audience (`str`, *optional*):
+            The `aud` claim to request. Defaults to `constants.ENDPOINT` so it matches the endpoint
+            that validates it (respects `HF_ENDPOINT`/staging).
+
+    Returns:
+        `str`: The raw id token (JWT) to pass to [`exchange_oidc_token`].
+    """
+    audience = audience or constants.ENDPOINT
+    provider = provider or detect_provider()
+    supported = ", ".join(p.value for p in Provider)
+    if provider is None:
+        raise OIDCError(f"No supported CI OIDC provider detected. Trusted Publishers currently supports: {supported}.")
+    if provider == Provider.GITHUB:
+        return _get_github_oidc_token(audience)
+    raise NotImplementedError(f"OIDC provider '{provider}' is not supported yet. Supported: {supported}.")
+
+
+def exchange_oidc_token(*, subject_token: str, resource: str, endpoint: str | None = None) -> dict:
+    """Exchange a CI OIDC id token for a short-lived Hugging Face token (RFC 8693).
+
+    Args:
+        subject_token (`str`):
+            The raw OIDC id token (JWT) from the CI provider. Its `aud` claim must be the Hub URL.
+        resource (`str`):
+            What to scope the token to: a Hub repo (`namespace/name`, `datasets/namespace/name`,
+            `spaces/namespace/name`, `kernels/namespace/name`) for a write token, or a bare Hub
+            username for a read-only `gated-repos` token.
+        endpoint (`str`, *optional*):
+            Hub endpoint. Defaults to `constants.ENDPOINT` (respects `HF_ENDPOINT`/staging).
+
+    Returns:
+        `dict`: The token-exchange response, e.g.
+        `{"access_token": "hf_jwt_…", "token_type": "bearer", "expires_in": 3600, ...}`.
+    """
+    response = get_session().post(
+        f"{endpoint or constants.ENDPOINT}/oauth/token",
+        json={
+            "grant_type": _TOKEN_EXCHANGE_GRANT_TYPE,
+            "subject_token_type": _ID_TOKEN_TYPE,
+            "subject_token": subject_token,
+            "resource": resource,
+        },
+    )
+    hf_raise_for_status(response)
+    return response.json()
+
+
+def oidc_login(
+    *,
+    resource: str,
+    subject_token: str | None = None,
+    provider: Provider | str | None = None,
+    audience: str | None = None,
+    endpoint: str | None = None,
+) -> dict:
+    """Mint a CI OIDC id token and exchange it for a Hugging Face token.
+
+    Convenience wrapper around [`get_oidc_token`] + [`exchange_oidc_token`]. Returns the raw
+    exchange response (it does not persist anything — the caller decides what to do with the token).
+
+    Args:
+        resource (`str`):
+            Repo or username to scope the token to. See [`exchange_oidc_token`].
+        subject_token (`str`, *optional*):
+            A pre-minted OIDC id token to exchange directly. Use this for CI providers not yet
+            supported natively (e.g. GitLab): mint the id token in your job and pass it here. When
+            omitted, the token is minted from the detected `provider`.
+        provider (`str`, *optional*):
+            CI provider. Auto-detected when omitted. Ignored when `subject_token` is provided.
+        audience (`str`, *optional*):
+            The `aud` claim to request. Defaults to the resolved `endpoint`, so it matches the
+            endpoint that validates it.
+        endpoint (`str`, *optional*):
+            Hub endpoint. Defaults to `constants.ENDPOINT`.
+
+    Returns:
+        `dict`: The token-exchange response (`access_token`, `token_type`, `expires_in`, ...).
+    """
+    endpoint = endpoint or constants.ENDPOINT
+    if subject_token is None:
+        subject_token = get_oidc_token(provider=provider, audience=audience or endpoint)
+    return exchange_oidc_token(subject_token=subject_token, resource=resource, endpoint=endpoint)

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_sandbox.py

@@ -0,0 +1,1764 @@
+# coding=utf-8
+# 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.
+import hashlib
+import hmac
+import json
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from pathlib import Path
+from secrets import token_hex
+from typing import Any, BinaryIO, Callable, Iterator, List, Literal, overload
+
+import httpx
+
+from . import constants
+from ._sandbox_cache import (
+    CachedHost,
+    delete_pool_cache,
+    read_pool_cache,
+    save_pool_cache,
+)
+from ._space_api import Volume
+from .errors import HfHubHTTPError, SandboxCommandError, SandboxError
+from .hf_api import HfApi, JobInfo
+from .utils import get_token, logging
+from .utils._parsing import parse_duration
+
+
+logger = logging.get_logger(__name__)
+
+# Port the sandbox server listens on inside the job. Deliberately uncommon so that typical user ports stay free.
+SANDBOX_SERVER_PORT = 49983
+
+# Stable marker present on every sandbox job to ease filtering
+SANDBOX_LABEL = "hf-sandbox"
+# Sandbox mode: "dedicated" or "pool" to ease filtering
+MODE_LABEL = "hf-sandbox-mode"
+MODE_DEDICATED = "dedicated"
+MODE_POOL = "pool"
+# Pool name, to scope host reuse to a named group (see SandboxPool(name=...)). Present on pool
+# host jobs only. Pool config (capacity, idle timeout) lives in the host's env vars, read via
+# inspect_job — labels are kept for filtering/grouping only.
+POOL_LABEL = "hf-sandbox-pool"
+# Per-job public nonce the sandbox token is derived from (see _derive_sandbox_token), so
+# `Sandbox.connect(id)` can recompute the token from any machine with no local state.
+NONCE_LABEL = "hf-sandbox-nonce"
+
+DEFAULT_IMAGE = "python:3.12"
+
+DEFAULT_IDLE_TIMEOUT = 10 * 60  # 10 minutes
+SANDBOX_MAX_LIFETIME = "24h"
+
+DEFAULT_SANDBOXES_PER_HOST = 50
+
+SHARED_ID_SEP = "."
+
+# Job stages in which a sandbox/host is finished and needs no teardown.
+_TERMINAL_STAGES = ("COMPLETED", "ERROR", "DELETED", "CANCELED")
+
+# Safety bound on create()'s pack-retry loop
+_MAX_PACK_ROUNDS = 8
+
+# hf-mount path where the server bucket is mounted on every sandbox job
+_SERVER_MOUNT_PATH = "/.hf-sbx-server"
+
+# Job startup script (needs only /bin/sh)
+_BOOTSTRAP_DOWNLOAD = """\
+set -e
+d=/tmp/.sbx-server
+if command -v wget >/dev/null 2>&1; then wget -q --header "Authorization: Bearer $SBX_DL_TOKEN" -O "$d" "$SBX_SERVER_URL"
+elif command -v curl >/dev/null 2>&1; then curl -fsSL -H "Authorization: Bearer $SBX_DL_TOKEN" -o "$d" "$SBX_SERVER_URL"
+else cp "$SBX_SERVER_MOUNT/sbx-server" "$d"; fi
+chmod +x "$d"
+unset SBX_DL_TOKEN SBX_SERVER_URL SBX_SERVER_MOUNT
+exec "$d"
+"""
+
+
+def _derive_sandbox_token(hf_token: str, nonce: str) -> str:
+    """Derive the per-sandbox auth token from the user's HF token and the sandbox nonce.
+
+    Stateless: any machine holding the same HF token can recompute it from the
+    nonce stored in the job's labels, so `Sandbox.connect(job_id)` needs no local state.
+    The HF token itself is never sent to the sandbox.
+    """
+    return hmac.new(hf_token.encode(), f"hf-sandbox:{nonce}".encode(), hashlib.sha256).hexdigest()
+
+
+def _duration_to_secs(duration: int | float | str) -> int:
+    """Parse a duration like 300, "300s", "10m", "2h", "1d" into seconds."""
+    if isinstance(duration, (int, float)):
+        return int(duration)
+    return parse_duration(duration)
+
+
+@dataclass
+class SandboxCommandResult:
+    """Result of a command executed in a sandbox with [`Sandbox.run`]."""
+
+    exit_code: int | None
+    stdout: str
+    stderr: str
+    signal: int | None = None
+    timed_out: bool = False
+    duration_ms: int = 0
+
+    @property
+    def ok(self) -> bool:
+        return self.exit_code == 0
+
+    def __repr__(self) -> str:
+        out = self.stdout if len(self.stdout) <= 80 else self.stdout[:77] + "..."
+        return f"SandboxCommandResult(exit_code={self.exit_code}, stdout={out!r}, duration_ms={self.duration_ms})"
+
+
+@dataclass
+class SandboxProcess:
+    """A background process started in a sandbox with [`Sandbox.run`]`(..., background=True)`.
+
+    List a sandbox's processes with [`Sandbox.processes`] and stop one with [`SandboxProcess.kill`].
+    Completed processes stay in the listing until the sandbox is deleted, so `running` and
+    `exit_code` tell whether a process is still alive or already exited (as of when it was listed).
+    """
+
+    pid: int
+    cmd: str | List[str]
+    # Back-reference to the sandbox, used by `kill()`. Excluded from repr/eq so a process
+    # stays a plain data object (and two with the same pid compare equal).
+    _sandbox: "Sandbox" = field(repr=False, compare=False)
+    tag: str | None = None
+    started_at_ms: int | None = None
+    running: bool = True
+    exit_code: int | None = None
+
+    def kill(self) -> None:
+        """Terminate the background process (idempotent server-side)."""
+        self._sandbox._request("DELETE", f"/processes/{self.pid}")
+
+
+@dataclass
+class FileEntry:
+    """A file or directory inside a sandbox."""
+
+    name: str
+    path: str
+    type: Literal["file", "dir", "symlink"]
+    size: int
+    mtime_ms: int | None = None
+    mode: str = ""
+
+
+class SandboxFiles:
+    """Filesystem operations inside a sandbox, available as [`Sandbox.files`].
+
+    In shared (pool) mode, paths are rooted at the sandbox's private home — the
+    only place its code can write — so a leading `/` is taken relative to that
+    home. In dedicated mode, paths are absolute on the container filesystem.
+    """
+
+    # Above this size, transfers are split into ranged requests over parallel
+    # connections: a single TCP stream through the jobs proxy is limited by the
+    # bandwidth-delay product (~2 MiB/s at ~100ms RTT); parallel streams scale it.
+    PARALLEL_THRESHOLD = 2 * 1024 * 1024
+    PARALLEL_CHUNK_SIZE = 1 * 1024 * 1024
+    PARALLEL_MAX_WORKERS = 16
+
+    def __init__(self, sandbox: "Sandbox") -> None:
+        self._sandbox = sandbox
+
+    def read(self, path: str) -> bytes:
+        """Read a file from the sandbox and return its content as bytes."""
+        size = self.stat(path).size
+        if size > self.PARALLEL_THRESHOLD:
+            return b"".join(self._read_ranges(path, size))
+        response = self._sandbox._request("GET", "/files/read", params={"path": path})
+        return response.content
+
+    def read_text(self, path: str, encoding: str = "utf-8") -> str:
+        """Read a file from the sandbox and return its content as a string."""
+        return self.read(path).decode(encoding)
+
+    def write(self, path: str, data: str | bytes | BinaryIO, mode: str | None = None) -> None:
+        """Write content to a file in the sandbox (parent directories are created)."""
+        if isinstance(data, str):
+            data = data.encode()
+        elif not isinstance(data, bytes):
+            data = data.read()  # binary file object
+        if len(data) > self.PARALLEL_THRESHOLD:
+            self._write_ranges(path, data, mode)
+            return
+        params = {"path": path}
+        if mode is not None:
+            params["mode"] = mode
+        self._sandbox._request("PUT", "/files/write", params=params, content=data)
+
+    def upload(self, local_path: str | Path, path: str, mode: str | None = None) -> None:
+        """Upload a local file to the sandbox."""
+        size = Path(local_path).stat().st_size
+        if size > self.PARALLEL_THRESHOLD:
+            self._write_ranges(path, Path(local_path).read_bytes(), mode)
+            return
+        with open(local_path, "rb") as f:
+            self.write(path, f, mode=mode)
+
+    def download(self, path: str, local_path: str | Path) -> None:
+        """Download a file from the sandbox."""
+        size = self.stat(path).size
+        if size > self.PARALLEL_THRESHOLD:
+            with open(local_path, "wb") as f:
+                for part in self._read_ranges(path, size):
+                    f.write(part)
+            return
+        with self._sandbox._stream("GET", "/files/read", params={"path": path}) as response:
+            with open(local_path, "wb") as f:
+                for chunk in response.iter_bytes(chunk_size=1024 * 1024):
+                    f.write(chunk)
+
+    def _ranges(self, size: int) -> List[tuple[int, int]]:
+        chunk = self.PARALLEL_CHUNK_SIZE
+        return [(offset, min(chunk, size - offset)) for offset in range(0, size, chunk)]
+
+    def _parallel(self, items: List[Any], fn: Callable[[Any], Any]) -> List[Any]:
+        """Run `fn(item)` over items concurrently.
+
+        All workers share the sandbox's `httpx.Client`, which is thread-safe and pools
+        connections, so parallel transfers fan out over several streams at once.
+        """
+        workers = min(self.PARALLEL_MAX_WORKERS, len(items))
+        with ThreadPoolExecutor(workers) as executor:
+            return list(executor.map(fn, items))
+
+    def _read_ranges(self, path: str, size: int) -> List[bytes]:
+        def fetch(rng: tuple[int, int]) -> bytes:
+            offset, length = rng
+            response = self._sandbox._request(
+                "GET", "/files/read", params={"path": path, "offset": offset, "length": length}
+            )
+            return response.content
+
+        return self._parallel(self._ranges(size), fetch)
+
+    def _write_ranges(self, path: str, data: bytes, mode: str | None) -> None:
+        def push(rng: tuple[int, int]) -> None:
+            offset, length = rng
+            params: dict[str, Any] = {"path": path, "offset": offset}
+            if mode is not None:
+                params["mode"] = mode
+            self._sandbox._request("PUT", "/files/write", params=params, content=data[offset : offset + length])
+
+        self._parallel(self._ranges(len(data)), push)
+
+    def list(self, path: str) -> List[FileEntry]:
+        """List a directory in the sandbox."""
+        response = self._sandbox._request("GET", "/files/list", params={"path": path})
+        return [FileEntry(**entry) for entry in response.json()["entries"]]
+
+    def stat(self, path: str) -> FileEntry:
+        """Get metadata of a file or directory in the sandbox."""
+        response = self._sandbox._request("GET", "/files/stat", params={"path": path})
+        return FileEntry(**response.json())
+
+    def exists(self, path: str) -> bool:
+        """Check whether a path exists in the sandbox."""
+        try:
+            self.stat(path)
+            return True
+        except SandboxError as e:
+            if e.status_code == 404:
+                return False
+            raise  # network/auth/server errors must not be silently reported as "missing"
+
+    def delete(self, path: str, recursive: bool = False) -> None:
+        """Delete a file or directory in the sandbox."""
+        params = {"path": path}
+        if recursive:
+            params["recursive"] = "1"
+        self._sandbox._request("DELETE", "/files/delete", params=params)
+
+    def mkdir(self, path: str) -> None:
+        """Create a directory (and parents) in the sandbox."""
+        self._sandbox._request("POST", "/files/mkdir", params={"path": path})
+
+
+def _exec_payload(cmd: str | List[str], shell: bool | None) -> dict[str, Any]:
+    """Build the `cmd`/`shell` part of an `/exec` payload, validating their consistency."""
+    if shell is True and not isinstance(cmd, str):
+        raise ValueError("shell=True requires `cmd` to be a shell command string, not a list.")
+    if shell is False and isinstance(cmd, str):
+        raise ValueError("shell=False requires `cmd` to be an argv list (e.g. ['echo', 'hi']), not a string.")
+    payload: dict[str, Any] = {"cmd": cmd}
+    if shell is not None:
+        payload["shell"] = shell
+    return payload
+
+
+def _iter_events(response: httpx.Response) -> Iterator[dict]:
+    """Iterate NDJSON events from a streaming response, skipping keepalive pings."""
+    for line in response.iter_lines():
+        if not line:
+            continue
+        event = json.loads(line)
+        if event.get("event") != "ping":
+            yield event
+
+
+def _raise_for_status(response: httpx.Response) -> None:
+    """Read the error body and raise a SandboxError (works for streaming responses too)."""
+    response.read()  # no-op for buffered responses, reads the body for streaming ones
+    try:
+        message = response.json()["error"]
+    except Exception:
+        message = response.text[:500]
+    raise SandboxError(f"Sandbox API error ({response.status_code}): {message}", status_code=response.status_code)
+
+
+class _SandboxServer:
+    """HTTP transport to one `sbx-server` instance — a dedicated job or a shared host.
+
+    Owns the `httpx.Client`, the base URL and the auth headers.
+    In dedicated mode a server is paired 1:1 with its [`Sandbox`
+    In pool mode one server (one host job) is shared by many sandboxes, and `live`/`capacity` track packing.
+    """
+
+    def __init__(
+        self,
+        *,
+        job_id: str,
+        owner: str,
+        image: str | None,
+        base_url: str,
+        nonce: str,
+        sandbox_token: str,
+        api: HfApi,
+        max_connections: int = 10,
+        capacity: int = 0,
+    ) -> None:
+        self.job_id = job_id
+        self.owner = owner
+        self._image = image
+        self.base_url = base_url
+        # Public nonce the sandbox token is derived from; kept so a host can be persisted
+        # to (and rebuilt from) the pool cache without re-reading the job labels.
+        self.nonce = nonce
+        self._api = api
+        self._auth_token = _effective_token(api)
+        self._sandbox_token = sandbox_token
+        # Packing bookkeeping (shared mode only).
+        self.capacity = capacity
+        self.live = 0
+        # False only for hosts rebuilt from the (best-effort) pool cache: their job may
+        # be gone, so the first failed request drops them instead of failing the create.
+        self.verified = True
+        # httpx.Client is thread-safe, so a single client serves both sequential requests
+        # and the concurrent workers used for parallel file transfers / many sandboxes.
+        self._client = httpx.Client(
+            headers={
+                "Authorization": f"Bearer {self._auth_token}",
+                "X-Sandbox-Token": sandbox_token,
+            },
+            limits=httpx.Limits(max_connections=max_connections, max_keepalive_connections=max_connections),
+            follow_redirects=True,
+        )
+
+    @classmethod
+    def from_job(
+        cls,
+        *,
+        job: JobInfo,
+        nonce: str,
+        sandbox_token: str,
+        api: HfApi,
+        max_connections: int = 10,
+        capacity: int = 0,
+    ) -> "_SandboxServer":
+        """Build a server from a freshly fetched job (reads its exposed server URL)."""
+        return cls(
+            job_id=job.id,
+            owner=job.owner.name,
+            image=job.docker_image or job.space_id,
+            base_url=_find_server_url(job),
+            nonce=nonce,
+            sandbox_token=sandbox_token,
+            api=api,
+            max_connections=max_connections,
+            capacity=capacity,
+        )
+
+    @property
+    def image(self) -> str | None:
+        return self._image
+
+    def request(self, method: str, path: str, **kwargs) -> httpx.Response:
+        """Request to the in-job server. Raises SandboxError on API errors."""
+        timeout = kwargs.pop("timeout", httpx.Timeout(60.0, connect=10.0))
+        response = self._client.request(method, self.base_url + path, timeout=timeout, **kwargs)
+        if response.status_code >= 400:
+            _raise_for_status(response)
+        return response
+
+    @contextmanager
+    def stream(self, method: str, path: str, **kwargs) -> Iterator[httpx.Response]:
+        """Streaming request to the in-job server. Raises SandboxError on API errors."""
+        timeout = kwargs.pop("timeout", httpx.Timeout(70.0, connect=10.0))  # server pings every 15s
+        with self._client.stream(method, self.base_url + path, timeout=timeout, **kwargs) as response:
+            if response.status_code >= 400:
+                _raise_for_status(response)
+            yield response
+
+    def close(self) -> None:
+        self._client.close()
+
+    def cancel_job(self) -> None:
+        self._api.cancel_job(job_id=self.job_id, namespace=self.owner)
+
+    def wait_ready(self, start_timeout: float) -> None:
+        """Poll /health until the server answers; fail fast (with logs) if the job dies."""
+        deadline = time.time() + start_timeout
+        last_job_check = 0.0
+        while time.time() < deadline:
+            try:
+                response = self._client.get(self.base_url + "/health", timeout=httpx.Timeout(5.0))
+                if response.status_code == 200:
+                    return
+            except httpx.RequestError:
+                pass
+            if time.time() - last_job_check > 2.0:
+                last_job_check = time.time()
+                job = self._api.inspect_job(job_id=self.job_id, namespace=self.owner)
+                if job.status.stage in _TERMINAL_STAGES:
+                    logs = _tail_job_logs(self._api, self.job_id, namespace=self.owner)
+                    raise SandboxError(
+                        f"Sandbox job {self.job_id} terminated during startup "
+                        f"(status: {job.status.stage}, message: {job.status.message}).{logs}"
+                    )
+            time.sleep(0.15)
+        raise SandboxError(f"Sandbox job {self.job_id} did not become ready within {start_timeout:.0f}s.")
+
+
+class _KillMethod:
+    """Lets `kill` work both as a classmethod and an instance method."""
+
+    @overload
+    def __get__(self, instance: None, owner: type) -> Callable[..., None]: ...
+    @overload
+    def __get__(self, instance: "Sandbox", owner: type) -> Callable[[], None]: ...
+    def __get__(self, instance: "Sandbox | None", owner: type) -> Callable[..., None]:
+        if instance is not None:
+            return instance._kill
+
+        def kill(sandbox_id: str, *, namespace: str | None = None, token: str | None = None) -> None:
+            owner.connect(sandbox_id, namespace=namespace, token=token).kill()  # type: ignore[attr-defined]
+
+        return kill
+
+
+class Sandbox:
+    """An isolated cloud machine running on Hugging Face Jobs.
+
+    Create a dedicated one with [`Sandbox.create`] (one job per sandbox), or get many cheap shared ones from a [`SandboxPool`].
+    Reattach to a running sandbox from anywhere with [`Sandbox.connect`]. Use as a context manager to terminate it on exit:
+
+    ```python
+    >>> from huggingface_hub import Sandbox
+    >>> with Sandbox.create(image="python:3.12") as sbx:
+    ...     print(sbx.run("python --version").stdout)
+    ```
+    """
+
+    def __init__(
+        self,
+        *,
+        id: str,
+        server: _SandboxServer,
+        local_id: str | None,
+        owns_sandbox: bool,
+        owns_server: bool,
+    ) -> None:
+        self.id = id
+        self._server = server
+        # None in dedicated mode; the host-local sandbox id in shared mode.
+        self._local_id = local_id
+        # Path prefix for all in-server operations: dedicated routes live under
+        # /v1/*, shared ones under /v1/sandboxes/<local_id>/*.
+        self._base_path = "/v1" if local_id is None else f"/v1/sandboxes/{local_id}"
+        # Whether exiting a `with` block terminates the sandbox (True for sandboxes
+        # we created, False for ones reattached via connect()).
+        self._owns_sandbox = owns_sandbox
+        # Whether closing/killing this sandbox also closes the HTTP client. False
+        # for pool sandboxes, whose client (the host) is owned by the pool.
+        self._owns_server = owns_server
+        # Set by SandboxPool to free a packing slot when a shared sandbox is killed.
+        self._on_kill: Callable[["Sandbox"], None] | None = None
+        self._killed = False
+        self.files = SandboxFiles(self)
+
+    # ------------------------------------------------------------------ lifecycle
+
+    @classmethod
+    def create(
+        cls,
+        image: str = DEFAULT_IMAGE,
+        *,
+        flavor: str = "cpu-basic",
+        idle_timeout: int | float | str | None = DEFAULT_IDLE_TIMEOUT,
+        env: dict[str, Any] | None = None,
+        secrets: dict[str, Any] | None = None,
+        volumes: List[Volume] | None = None,
+        namespace: str | None = None,
+        forward_hf_token: bool = False,
+        start_timeout: float = 120.0,
+        token: str | None = None,
+    ) -> "Sandbox":
+        """Create a dedicated sandbox (one HF Job) and block until it is ready (~7s on cpu-basic).
+
+        Each sandbox is a full isolated VM, so this is the right choice for GPU
+        workloads or untrusted code. To fan out many cheap CPU sandboxes instead, use
+        [`SandboxPool`].
+
+        The job runs with a fixed 24h maximum lifetime; `idle_timeout` is the real
+        keeper — an idle sandbox shuts itself down well before that.
+
+        Args:
+            image (`str`, *optional*, defaults to `"python:3.12"`):
+                Any Docker image with `/bin/sh` (Docker Hub or `hf.co/spaces/...`).
+            flavor (`str`, *optional*, defaults to `"cpu-basic"`):
+                Hardware flavor, e.g. `"cpu-basic"`, `"a10g-small"`. See `hf jobs hardware`.
+            idle_timeout (`int` or `float` or `str`, *optional*, defaults to `600`):
+                Auto-shutdown after this much inactivity (no API calls, no running
+                processes). Defaults to 10 minutes; pass `None` to disable.
+            env (`dict[str, Any]`, *optional*):
+                Environment variables available in the sandbox.
+            secrets (`dict[str, Any]`, *optional*):
+                Secret environment variables (encrypted server-side).
+            volumes (`List[Volume]`, *optional*):
+                HF repos/buckets to mount, see [`Volume`].
+            namespace (`str`, *optional*):
+                User or org namespace to run under (defaults to current user).
+            forward_hf_token (`bool`, *optional*, defaults to `False`):
+                If True, your HF token is injected as `HF_TOKEN` (opt-in).
+            start_timeout (`float`, *optional*, defaults to `120.0`):
+                Max seconds to wait for the sandbox to become ready.
+            token (`str`, *optional*):
+                HF token override.
+
+        The image only needs `/bin/sh`. The sandbox server is downloaded at startup with
+        `wget`/`curl` if available, otherwise read off an always-mounted server bucket (which
+        adds ~2-3s to cold start, so shipping `wget`/`curl` keeps it fast).
+        """
+        api = HfApi(token=token)
+        hf_token = _effective_token(api)
+        nonce = token_hex(16)
+        sandbox_token = _derive_sandbox_token(hf_token, nonce)
+
+        command, job_env, job_secrets, job_volumes = _bootstrap_job_spec(
+            api,
+            hf_token,
+            env=env,
+            secrets=secrets,
+            volumes=volumes,
+            idle_timeout=idle_timeout,
+            forward_hf_token=forward_hf_token,
+            sandbox_token=sandbox_token,
+        )
+
+        job = api.run_job(
+            image=image,
+            command=command,
+            env=job_env,
+            secrets=job_secrets,
+            flavor=flavor,
+            timeout=SANDBOX_MAX_LIFETIME,
+            labels={SANDBOX_LABEL: "1", MODE_LABEL: MODE_DEDICATED, NONCE_LABEL: nonce},
+            volumes=job_volumes or None,
+            expose=[SANDBOX_SERVER_PORT],
+            namespace=namespace,
+        )
+        server: "_SandboxServer | None" = None
+        try:
+            server = _SandboxServer.from_job(
+                job=job,
+                nonce=nonce,
+                sandbox_token=sandbox_token,
+                api=api,
+                max_connections=SandboxFiles.PARALLEL_MAX_WORKERS + 2,
+            )
+            server.wait_ready(start_timeout)
+        except Exception:
+            # run_job already started a billable job; cancel it before re-raising so it
+            # doesn't linger as an orphan (e.g. if the server port isn't exposed or startup fails).
+            try:
+                api.cancel_job(job_id=job.id, namespace=job.owner.name)
+            except Exception as e:
+                logger.warning(f"Failed to cancel sandbox job {job.id} after startup failure: {e}")
+            if server is not None:
+                server.close()
+            raise
+        return cls(id=job.id, server=server, local_id=None, owns_sandbox=True, owns_server=True)
+
+    @classmethod
+    def connect(cls, sandbox_id: str, *, namespace: str | None = None, token: str | None = None) -> "Sandbox":
+        """Reattach to a running sandbox from anywhere, using only its id."""
+        api = HfApi(token=token)
+        sandbox_id, namespace = _split_sandbox_id(sandbox_id, namespace)
+        if SHARED_ID_SEP in sandbox_id:
+            host_job_id, local_id = sandbox_id.split(SHARED_ID_SEP, 1)
+            server = _connect_host(api, host_job_id, namespace=namespace)
+            try:
+                existing = {item["id"] for item in server.request("GET", "/v1/sandboxes").json()}
+                if local_id not in existing:
+                    raise SandboxError(f"Sandbox {sandbox_id} no longer exists on host {host_job_id}.")
+            except Exception:
+                server.close()  # don't leak the HTTP client when the host is gone/unreachable
+                raise
+            return cls(id=sandbox_id, server=server, local_id=local_id, owns_sandbox=False, owns_server=True)
+
+        job = api.inspect_job(job_id=sandbox_id, namespace=namespace)
+        labels = job.labels or {}
+        nonce = labels.get(NONCE_LABEL)
+        if labels.get(SANDBOX_LABEL) != "1" or nonce is None:
+            raise SandboxError(f"Job {sandbox_id} is not a sandbox (missing '{SANDBOX_LABEL}' label).")
+        if labels.get(MODE_LABEL) == MODE_POOL:
+            raise SandboxError(
+                f"Job {sandbox_id} is a sandbox host, not a single sandbox. Connect to one of its "
+                f"sandboxes with id '<host_job_id>{SHARED_ID_SEP}<local_id>'."
+            )
+        if job.status.stage != "RUNNING":
+            raise SandboxError(f"Sandbox {sandbox_id} is not running (status: {job.status.stage}).")
+        sandbox_token = _derive_sandbox_token(_effective_token(api), nonce)
+        server = _SandboxServer.from_job(
+            job=job,
+            nonce=nonce,
+            sandbox_token=sandbox_token,
+            api=api,
+            max_connections=SandboxFiles.PARALLEL_MAX_WORKERS + 2,
+        )
+        return cls(id=job.id, server=server, local_id=None, owns_sandbox=False, owns_server=True)
+
+    # `kill` is both a classmethod (`Sandbox.kill(id)`) and an instance method (`sbx.kill()`),
+    # dispatched by the `_KillMethod` descriptor; `_kill` holds the instance behaviour.
+    kill = _KillMethod()
+
+    def _kill(self) -> None:
+        """Terminate the sandbox. Idempotent.
+
+        Dedicated sandboxes cancel their underlying job; shared sandboxes are
+        removed from their host (freeing a slot) while the host keeps running.
+        """
+        if self._killed:
+            return
+        try:
+            if self._local_id is None:
+                self._server.cancel_job()
+            else:
+                self._server.request("DELETE", f"/v1/sandboxes/{self._local_id}")
+        except Exception as e:
+            # Don't mark as killed: a later kill() call should retry so nothing leaks.
+            logger.warning(f"Failed to kill sandbox {self.id}: {e}")
+            return
+        self._killed = True
+        if self._on_kill is not None:
+            self._on_kill(self)
+        if self._owns_server:
+            self._server.close()
+
+    def close(self) -> None:
+        """Release the local HTTP client without terminating the sandbox. Idempotent.
+
+        No-op for pool sandboxes (the client belongs to the pool's host).
+        """
+        if self._owns_server:
+            self._server.close()
+
+    def __enter__(self) -> "Sandbox":
+        return self
+
+    def __exit__(self, *exc_info) -> None:
+        if self._owns_sandbox:
+            self.kill()
+        else:
+            self.close()
+
+    # ------------------------------------------------------------------ exec
+
+    @overload
+    def run(
+        self,
+        cmd: str | List[str],
+        *,
+        shell: bool | None = ...,
+        env: dict[str, Any] | None = ...,
+        cwd: str | None = ...,
+        timeout: float | None = ...,
+        stdin: str | None = ...,
+        on_stdout: Callable[[str], None] | None = ...,
+        on_stderr: Callable[[str], None] | None = ...,
+        check: bool = ...,
+        background: Literal[False] = ...,
+    ) -> SandboxCommandResult: ...
+
+    @overload
+    def run(
+        self,
+        cmd: str | List[str],
+        *,
+        shell: bool | None = ...,
+        env: dict[str, Any] | None = ...,
+        cwd: str | None = ...,
+        background: Literal[True],
+    ) -> SandboxProcess: ...
+
+    def run(
+        self,
+        cmd: str | List[str],
+        *,
+        shell: bool | None = None,
+        env: dict[str, Any] | None = None,
+        cwd: str | None = None,
+        timeout: float | None = None,
+        stdin: str | None = None,
+        on_stdout: Callable[[str], None] | None = None,
+        on_stderr: Callable[[str], None] | None = None,
+        check: bool = True,
+        background: bool = False,
+    ) -> SandboxCommandResult | SandboxProcess:
+        """Run a command in the sandbox and wait for it, streaming output live.
+
+        With `background=True` the command is started detached and `run` returns a
+        [`SandboxProcess`] immediately, without waiting for it to finish — handy for
+        servers and other long-running processes. List them later with [`Sandbox.processes`]
+        and stop one with [`SandboxProcess.kill`]. The streaming/wait-only options
+        (`timeout`, `stdin`, `on_stdout`, `on_stderr`, `check`) don't apply in that mode.
+
+        Args:
+            cmd (`str` or `List[str]`):
+                A shell command string (run with `/bin/sh -c`) or an argv list (exec'd directly).
+            shell (`bool`, *optional*):
+                Force the execution mode instead of inferring it from the type of `cmd`.
+                `True` runs through `/bin/sh -c` and requires `cmd` to be a string; `False`
+                exec's `cmd` directly and requires it to be an argv list. `None` (default)
+                infers from the type. Set it explicitly to avoid the type-driven footgun (e.g.
+                `["echo hi"]` being exec'd as a single program named `"echo hi"`).
+            env (`dict[str, Any]`, *optional*):
+                Extra environment variables for this command.
+            cwd (`str`, *optional*):
+                Working directory.
+            timeout (`float`, *optional*):
+                Kill the command (whole process group) after this many seconds.
+            stdin (`str`, *optional*):
+                Data to write to the command's stdin.
+            on_stdout (`Callable[[str], None]`, *optional*):
+                Callback invoked with stdout chunks as they arrive.
+            on_stderr (`Callable[[str], None]`, *optional*):
+                Callback invoked with stderr chunks as they arrive.
+            check (`bool`, *optional*, defaults to `True`):
+                If True, raise [`SandboxCommandError`] on non-zero exit.
+            background (`bool`, *optional*, defaults to `False`):
+                If True, start the command detached and return a [`SandboxProcess`] right
+                away instead of waiting for it and returning a [`SandboxCommandResult`].
+
+        Returns: a [`SandboxCommandResult`] (with `exit_code`, `stdout`, `stderr`,
+        `duration_ms`), or a [`SandboxProcess`] when `background=True`.
+        """
+        payload = _exec_payload(cmd, shell)
+        if env:
+            payload["env"] = env
+        if cwd:
+            payload["cwd"] = cwd
+        if background:
+            data = self._request("POST", "/processes", json=payload).json()
+            return SandboxProcess(pid=data["pid"], cmd=cmd, tag=data.get("tag"), _sandbox=self)
+        if timeout is not None:
+            payload["timeout"] = timeout
+        if stdin is not None:
+            payload["stdin"] = stdin
+
+        stdout_parts: list[str] = []
+        stderr_parts: list[str] = []
+        result: SandboxCommandResult | None = None
+        with self._stream("POST", "/exec", json=payload) as response:
+            for event in _iter_events(response):
+                if event["event"] == "stdout":
+                    stdout_parts.append(event["data"])
+                    if on_stdout is not None:
+                        on_stdout(event["data"])
+                elif event["event"] == "stderr":
+                    stderr_parts.append(event["data"])
+                    if on_stderr is not None:
+                        on_stderr(event["data"])
+                elif event["event"] == "exit":
+                    result = SandboxCommandResult(
+                        exit_code=event["exit_code"],
+                        stdout="".join(stdout_parts),
+                        stderr="".join(stderr_parts),
+                        signal=event.get("signal"),
+                        timed_out=event.get("timed_out", False),
+                        duration_ms=event.get("duration_ms", 0),
+                    )
+        if result is None:
+            raise SandboxError("connection lost while running command")
+        if check and (result.exit_code != 0 or result.timed_out):
+            raise SandboxCommandError(cmd=cmd, result=result)
+        return result
+
+    def processes(self) -> List[SandboxProcess]:
+        """List the background processes of this sandbox.
+
+        Returns the processes started with [`Sandbox.run`]`(..., background=True)`; stop one
+        with [`SandboxProcess.kill`]. Completed processes stay listed (with `running=False` and
+        their `exit_code`) until the sandbox is deleted.
+        """
+        data = self._request("GET", "/processes").json()
+        return [
+            SandboxProcess(
+                pid=p["pid"],
+                cmd=p["cmd"],
+                tag=p.get("tag"),
+                started_at_ms=p.get("started_at_ms"),
+                running=p["running"],
+                exit_code=p.get("exit_code"),
+                _sandbox=self,
+            )
+            for p in data
+        ]
+
+    # ------------------------------------------------------------------ misc
+
+    @property
+    def image(self) -> str | None:
+        return self._server.image
+
+    @property
+    def host_id(self) -> str | None:
+        """For a shared/pool sandbox, the job id of the host running it (else None)."""
+        return self._server.job_id if self._local_id is not None else None
+
+    # ------------------------------------------------------------------ port proxy
+
+    def proxy_url_for(self, port: int | str, path: str = "/", *, scheme: str = "https://") -> str:
+        """Public URL that proxies through to a server running *inside* this sandbox.
+
+        Requests to the returned URL are forwarded by the in-job sandbox server to a
+        server you started in the sandbox on `port`, including WebSocket (`ws(s)://`)
+        upgrades and streamed responses. Pair it with [`proxy_headers`] for auth.
+
+        How the sandbox must listen on `port`:
+
+        - **Pool / shared sandbox**: it cannot bind a TCP port (Landlock), so bind a
+          **unix socket** at `$SBX_PROXY_DIR/<port>.sock` (the `SBX_PROXY_DIR` env var
+          is set in every sandbox). E.g. `uvicorn app:app --uds $SBX_PROXY_DIR/8000.sock`.
+        - **Dedicated sandbox**: bind a normal TCP port on `127.0.0.1:<port>`. (You can
+          also expose the port directly via the job proxy without going through here.)
+
+        Args:
+            port (`int` or `str`):
+                The port (pool: the `<port>` of the unix socket) the inner server listens on.
+            path (`str`, *optional*, defaults to `"/"`):
+                Path on the inner server to point at, e.g. `"/ws"`.
+            scheme (`str`, *optional*, defaults to `"https://"`):
+                URL scheme to build the link with. Defaults to `"https://"`; pass
+                `"wss://"` for a WebSocket client (the proxy is protocol-agnostic, so only
+                the client-side scheme changes).
+
+        Returns:
+            `str`: a URL like `https://<job_id>--49983.hf.jobs/v1/.../proxy/8000/ws` (or
+            `wss://...` with `scheme="wss://"`).
+
+        Example:
+            ```python
+            >>> url = sandbox.proxy_url_for(8000, "/ws", scheme="wss://")
+            >>> import websockets
+            >>> async with websockets.connect(url, additional_headers=sandbox.proxy_headers) as ws:
+            ...     await ws.send("hello")
+            ```
+        """
+        # base_url is always https://...; swap in the requested scheme (e.g. wss://) for the client.
+        host_and_rest = self._server.base_url.split("://", 1)[-1]
+        path = path if path.startswith("/") else "/" + path
+        return f"{scheme}{host_and_rest}{self._base_path}/proxy/{port}{path}"
+
+    @property
+    def proxy_headers(self) -> dict[str, str]:
+        """Auth headers to send with [`proxy_url_for`] requests (HF token + sandbox token)."""
+        return {
+            "Authorization": f"Bearer {self._server._auth_token}",
+            "X-Sandbox-Token": self._server._sandbox_token,
+        }
+
+    def __repr__(self) -> str:
+        return f"Sandbox(id={self.id!r}, image={self.image!r})"
+
+    # ------------------------------------------------------------------ internals
+
+    def _request(self, method: str, resource: str, **kwargs) -> httpx.Response:
+        return self._server.request(method, self._base_path + resource, **kwargs)
+
+    @contextmanager
+    def _stream(self, method: str, resource: str, **kwargs) -> Iterator[httpx.Response]:
+        with self._server.stream(method, self._base_path + resource, **kwargs) as response:
+            yield response
+
+
+class SandboxPool:
+    """A fleet of shared "host" jobs, each packing many landlock-isolated sandboxes.
+
+    One host is one billed HF Job (a VM); it runs the sandbox server and multiplexes
+    up to `sandboxes_per_host` lightweight sandboxes, isolated from each other by
+    uid + the Landlock LSM. This makes large fan-outs cheap (the VM cost is shared
+    across all its sandboxes) and fast (creating a sandbox is ~one proxy round-trip
+    once a host is warm). Best for many parallel CPU sandboxes such as RL rollouts;
+    for GPU or strong VM-level isolation between mutually-distrusting workloads, use
+    [`Sandbox.create`] instead.
+
+    The constructor pre-provisions `warm_up` hosts (default 1) and blocks until they are
+    ready; further hosts are then provisioned on demand as sandboxes are requested, and all
+    are torn down on `close()` (or when idle, via `idle_timeout`). The user never manages jobs:
+
+    ```python
+    >>> from huggingface_hub import SandboxPool
+    >>> with SandboxPool(image="python:3.12", flavor="cpu-basic", warm_up=2) as pool:
+    ...     boxes = [pool.create() for _ in range(100)]   # packed across the warm hosts
+    ...     print(boxes[0].run("echo hi").stdout)
+    hi
+    ```
+
+    `create()` makes **one** sandbox at a time: it reuses a host that still has free
+    capacity before booting a new one, so you grow on demand as work arrives. To avoid
+    a cold start on the first few calls, pre-provision hosts with `warm_up` (or
+    [`warm`]). Warm hosts are discovered via job labels, so reuse works **across
+    processes** too (a fresh pool with the same `image`/`flavor`/`name` attaches to
+    hosts an earlier run left behind):
+
+    ```python
+    >>> pool = SandboxPool(image="python:3.12")
+    >>> sbx = pool.create()    # finds a warm host (here or in another process), else boots one
+    ```
+    """
+
+    def __init__(
+        self,
+        image: str = DEFAULT_IMAGE,
+        *,
+        flavor: str = "cpu-basic",
+        sandboxes_per_host: int = DEFAULT_SANDBOXES_PER_HOST,
+        warm_up: int = 1,
+        max_hosts: int | None = None,
+        name: str | None = None,
+        idle_timeout: int | float | str | None = DEFAULT_IDLE_TIMEOUT,
+        namespace: str | None = None,
+        start_timeout: float = 120.0,
+        token: str | None = None,
+        _connect_mode: bool = False,
+    ) -> None:
+        """Configure a pool and pre-provision `warm_up` hosts (blocks until they are ready).
+
+        Env/secrets are *not* set here: they belong to each sandbox and are passed to
+        `create(env=...)`, so sandboxes in the same pool can have different environments.
+
+        Args:
+            image (`str`, *optional*, defaults to `"python:3.12"`):
+                Docker image for the hosts (needs `/bin/sh`). All sandboxes in the
+                pool share this image.
+            flavor (`str`, *optional*, defaults to `"cpu-basic"`):
+                Hardware flavor for the host jobs (e.g. `"cpu-basic"`).
+            sandboxes_per_host (`int`, *optional*, defaults to `50`):
+                How many sandboxes to pack per host (per VM density).
+            warm_up (`int`, *optional*, defaults to `1`):
+                How many hosts to pre-provision in the constructor (which blocks
+                until they are ready), so an initial burst of `create()` calls doesn't pay
+                a host cold start each. Existing warm hosts (from the cache / other processes)
+                count towards it, so only the shortfall is booted; capped by `max_hosts`.
+                Defaults to 1 (a single host).
+            max_hosts (`int`, *optional*):
+                Optional cap on the number of host jobs (a cost ceiling). When
+                reached and all hosts are full, `create()` raises.
+            name (`str`, *optional*):
+                Pool name, used as the `hf-sandbox-pool` job label so the pool is
+                discoverable (e.g. `hf sandbox pool ls`, `connect()`). `create()` reuses
+                running hosts carrying this label (including from other processes) before
+                booting new ones, so distinct names keep separate pools from sharing hosts.
+                A random name is generated when omitted.
+            idle_timeout (`int` or `float` or `str`, *optional*, defaults to `600`):
+                Host idle timeout — a host shuts down once it has had no
+                sandboxes for this long (a billing backstop). Each sandbox also has its
+                own idle timeout, set at `create()`. Pass `None` to disable.
+            namespace (`str`, *optional*):
+                User or org namespace to run hosts under.
+            start_timeout (`float`, *optional*, defaults to `120.0`):
+                Max seconds to wait for a host to become ready.
+            token (`str`, *optional*):
+                HF token override.
+        """
+        if sandboxes_per_host < 1:
+            raise ValueError("sandboxes_per_host must be >= 1.")
+        if warm_up < 1:
+            raise ValueError("warm_up must be >= 1.")
+        self._api = HfApi(token=token)
+        self.image = image
+        self.flavor = flavor
+        self.sandboxes_per_host = sandboxes_per_host
+        self._warm_up = warm_up
+        self.max_hosts = max_hosts
+        self.name = name if name is not None else f"pool-{token_hex(6)}"
+        self._idle_timeout = idle_timeout
+        self._namespace = namespace
+        self._start_timeout = start_timeout
+        self._hosts: List[_SandboxServer] = []
+        self._lock = threading.Lock()
+        # Held across the whole one-time warm-up so concurrent first create() calls block until
+        # it finishes (and see the warm hosts) instead of racing past a half-set flag.
+        self._warmup_lock = threading.Lock()
+        # Serializes on-demand host creation within the process: a burst of create() calls that
+        # all find every host full boots one host at a time (each new host frees
+        # `sandboxes_per_host` slots for the threads still queued behind the lock) instead of
+        # one host per thread. The CLI is a single process per command, so this is a no-op there.
+        self._boot_lock = threading.Lock()
+        self._closed = False
+        # Whether the one-time warm-up (seed cache + pre-provision `warm_up` hosts) ran.
+        self._warmed_up = False
+        # Set for connect()'d handles: the pool must already exist, so create() refuses to
+        # silently resurrect it by booting a fresh host if discovery confirms every host is gone.
+        # Such a handle also never boots during construction — it attaches lazily on create().
+        self._require_live_host = _connect_mode
+        # Whether close()/`__exit__` cancels the host jobs. True for a pool we created; False
+        # for a connect()'d handle, which only releases its HTTP clients on exit — the shared
+        # hosts (possibly serving other clients) are left running, like Sandbox.connect().
+        self._owns_hosts = not _connect_mode
+        # Job ids of cached hosts we found dead this session; pruned from the cache on save.
+        self._dead_host_ids: set[str] = set()
+
+        # Pre-provision `warm_up` hosts now so the constructor returns only once the pool is
+        # warm. A connect()'d handle skips this: it must never boot during construction (it can
+        # only attach to existing hosts, lazily on the first create()).
+        if not _connect_mode:
+            self._ensure_warmed_up()
+
+    # ------------------------------------------------------------------ public API
+
+    @classmethod
+    def connect(cls, pool_id: str, *, namespace: str | None = None, token: str | None = None) -> "SandboxPool":
+        """Reattach to a running pool by id, from any machine — no local state needed.
+
+        Finds a running host labelled with `pool_id` and rebuilds the pool's config
+        (image/flavor/density/host-idle) from that host job's spec and env vars, returning
+        a [`SandboxPool`] ready to `create()` more sandboxes — packing onto the running
+        hosts, or booting a duplicate (same config) when they are full.
+
+        Raises [`SandboxError`] if no running host is found (a pool stops existing once
+        all of its hosts are gone — idle-timed-out or killed).
+
+        Args:
+            pool_id (`str`):
+                The id returned when the pool was first created.
+            namespace (`str`, *optional*):
+                Namespace to search for the pool's hosts (defaults to yours).
+            token (`str`, *optional*):
+                HF token override.
+        """
+        # Fast path: rebuild the pool from the local best-effort cache, with no HTTP at all.
+        # The cached hosts are seeded (and verified) lazily on the next create(); if they are
+        # all stale, create() falls back to label discovery exactly like a cold connect would.
+        cache = read_pool_cache(pool_id)
+        if cache is not None:
+            return cls(
+                image=cache.image,
+                flavor=cache.flavor,
+                sandboxes_per_host=cache.sandboxes_per_host,
+                max_hosts=cache.max_hosts,
+                name=pool_id,
+                idle_timeout=cache.idle_timeout,
+                namespace=cache.namespace if namespace is None else namespace,
+                token=token,
+                _connect_mode=True,  # attach to existing hosts; never boot during construction
+            )
+
+        # Cold path: find a running host via labels and rebuild the config from its job spec.
+        api = HfApi(token=token)
+        job = _find_pool_host_job(api, pool_id, namespace=namespace)
+        env = _host_env(api, job, namespace=namespace)
+        idle_raw = env.get("SBX_IDLE_TIMEOUT")
+        max_hosts_raw = env.get("SBX_MAX_HOSTS")
+        return cls(
+            image=job.docker_image or job.space_id or DEFAULT_IMAGE,
+            flavor=str(job.flavor) if job.flavor is not None else "cpu-basic",
+            sandboxes_per_host=int(env.get("SBX_CAPACITY", DEFAULT_SANDBOXES_PER_HOST)),
+            max_hosts=int(max_hosts_raw) if max_hosts_raw is not None else None,
+            name=pool_id,
+            idle_timeout=int(idle_raw) if idle_raw is not None else None,
+            namespace=namespace,
+            token=token,
+            _connect_mode=True,  # attach to existing hosts; never boot during construction
+        )
+
+    def warm(self, num_hosts: int = 1) -> List[str]:
+        """Ensure `num_hosts` empty host(s) are running and leave them running. Returns the
+        pool's host job ids.
+
+        Used to "create" a pool up front: the hosts carry the pool label and config (in
+        their env vars), so a later `SandboxPool.connect(pool_id)` (even from another
+        machine) finds them and spawns sandboxes without a cold start. The hosts keep
+        billing until killed or idle.
+
+        Adopts hosts already running for this pool (found via job labels) before booting,
+        so a `warm()` after `connect()` — or a repeated `warm()` — tops up to `num_hosts`
+        instead of duplicating live hosts and blowing past `max_hosts`.
+        """
+        if self._closed:
+            raise SandboxError("This SandboxPool is closed.")
+        self._discover_hosts()
+        with self._lock:
+            shortfall = num_hosts - len(self._hosts)
+        if shortfall > 0:
+            booted = self._provision_hosts(shortfall)
+            with self._lock:
+                self._hosts.extend(booted)
+        with self._warmup_lock:
+            self._warmed_up = True  # explicit warm-up satisfies create()'s one-time warm-up
+        self._save_cache()
+        return self.host_ids
+
+    def create(
+        self,
+        *,
+        env: dict[str, Any] | None = None,
+        idle_timeout: int | float | str | None = DEFAULT_IDLE_TIMEOUT,
+        forward_hf_token: bool = False,
+    ) -> "Sandbox":
+        """Create one sandbox, provisioning a host if needed.
+
+        Reuses a host with free capacity (this pool's, or a warm host found via job labels
+        / the local cache) before booting a new one, so a `create()` against a warm host
+        costs ~one round-trip. Call it repeatedly to fan out; use `warm_up` (or [`warm`])
+        to pre-provision hosts and avoid a cold start on the first calls. If a host fills
+        up under us (another process packed it) or a cached host is gone, the sandbox is
+        re-placed on another host (or a fresh one).
+
+        Args:
+            env (`dict[str, Any]`, *optional*):
+                Environment variables for this sandbox (each sandbox gets its own).
+            idle_timeout (`int` or `float` or `str`, *optional*, defaults to `600`):
+                Per-sandbox idle timeout — a sandbox is evicted from its host
+                after this much inactivity (no API calls, no running process). Distinct
+                from the host idle timeout. Pass `None` to disable.
+            forward_hf_token (`bool`, *optional*, defaults to `False`):
+                If True, inject your HF token as `HF_TOKEN` in the sandbox
+                (opt-in). Unlike a dedicated sandbox's `secrets`, a pooled sandbox's env is
+                delivered to the host server at creation (never stored in the host job), so
+                it doesn't appear in any job's metadata.
+        """
+        if self._closed:
+            raise SandboxError("This SandboxPool is closed.")
+        sandbox_env = dict(env or {})
+        if forward_hf_token:
+            sandbox_env["HF_TOKEN"] = _effective_token(self._api)
+        # None disables per-sandbox idle eviction (mirrors Sandbox.create): leave it out of
+        # the create body entirely rather than sending 0, which the server reads as "evict now".
+        idle_secs = _duration_to_secs(idle_timeout) if idle_timeout is not None else None
+
+        new_hosts: List[_SandboxServer] = []
+        discovered = False
+        rounds = 0
+        try:
+            # One-time warm-up: seed from cache (no HTTP) and pre-provision `warm_up` hosts.
+            # Warm-up hosts are pool-level (like `warm()`), so they survive a failed create().
+            self._ensure_warmed_up()
+            while True:
+                # 1. Reserve a slot on a host we already track.
+                host = self._reserve_one()
+                # 2. If none free, attach (once) to warm hosts discovered via labels.
+                if host is None and not discovered:
+                    discovered = True
+                    self._discover_hosts()
+                    host = self._reserve_one()
+                # 3. Still none? Boot one host (unless we must not resurrect a dead pool).
+                if host is None:
+                    if self._require_live_host and discovered and not self._hosts:
+                        # connect()'d to a pool whose hosts are all gone (stale cache + nothing
+                        # found via labels): don't resurrect it under the same id, just report it.
+                        delete_pool_cache(self.name)
+                        raise SandboxError(
+                            f"No running host found for pool '{self.name}'. The pool has stopped "
+                            "(all its hosts were killed or idle-timed-out); create a new one."
+                        )
+                    host = self._boot_one_host(new_hosts)
+                # 4. Create the sandbox on the reserved host. `None` means the host filled up
+                #    (another process packed it) or a stale cached host is gone — retry.
+                if host is not None:
+                    try:
+                        sandbox = self._create_one(host, sandbox_env, idle_secs)
+                    except Exception:
+                        # The create POST failed on a live host: release the slot we optimistically
+                        # reserved so the host isn't left permanently one sandbox short.
+                        with self._lock:
+                            host.live = max(0, host.live - 1)
+                        raise
+                    if sandbox is not None:
+                        self._save_cache()
+                        return sandbox
+                    # sandbox is None: the host is full (packed by another process) or gone.
+                    # Either way it's no longer a host we exclusively own, so stop tracking it
+                    # for teardown — cancelling it on a later round's failure would kill another
+                    # tenant's sandboxes (full host) or hit an already-dead job (gone host).
+                    if host in new_hosts:
+                        new_hosts.remove(host)
+                discovered = False  # re-scan for room / boot a host next round
+                rounds += 1
+                if rounds > _MAX_PACK_ROUNDS:
+                    raise SandboxError(
+                        "Could not place sandbox: hosts kept reporting full. Raise max_hosts or sandboxes_per_host."
+                    )
+        except Exception:
+            # All-or-nothing: tear down hosts we booted in this call.
+            with self._lock:
+                self._hosts = [h for h in self._hosts if h not in new_hosts]
+            for host in new_hosts:
+                try:
+                    host.cancel_job()
+                except Exception:
+                    pass
+                finally:
+                    host.close()
+            raise
+
+    @property
+    def num_hosts(self) -> int:
+        """Number of host jobs currently provisioned."""
+        with self._lock:
+            return len(self._hosts)
+
+    @property
+    def num_sandboxes(self) -> int:
+        """Number of sandboxes currently handed out (across all hosts)."""
+        with self._lock:
+            return sum(host.live for host in self._hosts)
+
+    @property
+    def host_ids(self) -> List[str]:
+        """Job ids of the provisioned hosts."""
+        with self._lock:
+            return [host.job_id for host in self._hosts]
+
+    def close(self) -> None:
+        """Release the pool. Idempotent.
+
+        For a pool we created, this terminates all host jobs (and therefore all their
+        sandboxes). For a `connect()`'d handle it only releases the local HTTP clients: the
+        shared hosts may be serving other clients, so — like [`Sandbox.connect`] — leaving a
+        `with` block must not tear them down. Terminate a connected pool's hosts explicitly
+        with `hf sandbox pool delete <id>`.
+        """
+        with self._lock:
+            hosts = self._hosts
+            self._hosts = []
+            self._closed = True
+        for host in hosts:
+            try:
+                if self._owns_hosts:
+                    host.cancel_job()
+            except Exception as e:
+                logger.warning(f"Failed to cancel sandbox host {host.job_id}: {e}")
+            finally:
+                host.close()
+        if self._owns_hosts:
+            delete_pool_cache(self.name)  # the pool's hosts are gone; don't leave a stale entry
+
+    def __enter__(self) -> "SandboxPool":
+        return self
+
+    def __exit__(self, *exc_info) -> None:
+        self.close()
+
+    # ------------------------------------------------------------------ internals
+
+    def _ensure_warmed_up(self) -> None:
+        """One-time: seed from the cache and pre-provision up to `warm_up` hosts.
+
+        Cheap by default: seeding is local (no HTTP), and if the cache already gives at
+        least `warm_up` hosts we trust them and skip discovery/booting (dead ones are
+        pruned lazily by `create()`). Only when short do we list_jobs and boot the
+        shortfall in parallel, capped by `max_hosts`.
+
+        Runs at most once per pool, under `_warmup_lock`: concurrent first `create()` calls
+        block here until the warm-up completes — and see its hosts — rather than racing past
+        a half-set flag and each booting their own. `_warmed_up` is only set once the work
+        succeeds, so a failed warm-up is retried (seeding/discovery dedupe by job id).
+
+        Warm-up hosts are pool-level (like [`warm`]): they are not torn down if the
+        triggering `create()` later fails — `close()` (or the `with` block) reclaims them.
+        """
+        with self._warmup_lock:
+            if self._warmed_up:
+                return
+            self._seed_hosts_from_cache()
+            target = self._warm_up if self.max_hosts is None else min(self._warm_up, self.max_hosts)
+            with self._lock:
+                shortfall = target - len(self._hosts)
+            if shortfall > 0:
+                self._discover_hosts()
+                # A connect()'d pool must never boot during warm-up: it may only attach to
+                # existing hosts. Booting is left to create()'s loop, guarded by
+                # `_require_live_host`, so a stopped pool is reported instead of resurrected.
+                if not self._require_live_host:
+                    with self._lock:
+                        shortfall = target - len(self._hosts)
+                    if shortfall > 0:
+                        booted = self._provision_hosts(shortfall)
+                        with self._lock:
+                            self._hosts.extend(booted)
+            self._warmed_up = True
+        # Persist the warmed hosts so the next process (e.g. `hf sandbox create --pool` after a
+        # bare `hf sandbox pool create`) hits the cache fast path instead of re-discovering.
+        if self._hosts:
+            self._save_cache()
+
+    def _reserve_one(self) -> "_SandboxServer | None":
+        """Reserve one slot on the first host with free capacity (under lock), else None."""
+        with self._lock:
+            for host in self._hosts:
+                if host.capacity - host.live > 0:
+                    host.live += 1
+                    return host
+        return None
+
+    def _boot_one_host(self, new_hosts: List["_SandboxServer"]) -> "_SandboxServer | None":
+        """Provision (or adopt) one host and reserve a slot on it. Returns None to retry.
+
+        Held under `_boot_lock` so that, within a process, only one host is booted at a time:
+        a burst of create() calls that all found every host full queue here, and each new host
+        frees `sandboxes_per_host` slots for the threads still waiting — so they reuse it instead
+        of each booting their own. Before booting, we reuse a slot freed by a concurrent boot and,
+        failing that, adopt a host already SCHEDULING for this pool (here or in another process)
+        rather than piling on a duplicate.
+        """
+        with self._boot_lock:
+            # A concurrent boot (this process) may have added a host with free slots while we
+            # waited for the lock — reuse it instead of booting another.
+            host = self._reserve_one()
+            if host is not None:
+                return host
+            # A host already coming up for this pool (ours, or another process'): wait for it
+            # to start and adopt it instead of booting a duplicate.
+            if self._adopt_pending_host():
+                host = self._reserve_one()
+                if host is not None:
+                    return host
+            booted = self._provision_hosts(1)
+            new_hosts.extend(booted)
+            with self._lock:
+                self._hosts.extend(booted)
+            return self._reserve_one()
+
+    def _adopt_pending_host(self) -> bool:
+        """Wait for and adopt a host already SCHEDULING for this pool, if any.
+
+        Avoids over-provisioning when a host is already on its way up for this pool (started by
+        another process, or an earlier create() in this one): rather than booting a duplicate,
+        wait for it to reach RUNNING and adopt it via discovery. Returns True if a pending host
+        was found (whether or not it eventually came up), False if none is scheduling.
+        """
+        known = {host.job_id for host in self._hosts}
+        pending = next(
+            (
+                job
+                for job in self._api.list_jobs(
+                    status="SCHEDULING",
+                    labels={MODE_LABEL: MODE_POOL, POOL_LABEL: self.name},
+                    namespace=self._namespace,
+                )
+                if job.id not in known
+            ),
+            None,
+        )
+        if pending is None:
+            return False
+        logger.debug(f"Pool '{self.name}' host {pending.id} is already SCHEDULING; waiting for it instead of booting.")
+        deadline = time.time() + self._start_timeout
+        while time.time() < deadline:
+            stage = self._api.inspect_job(job_id=pending.id, namespace=self._namespace).status.stage
+            if stage not in ("SCHEDULING", "RUNNING"):
+                return False  # it died before starting up; let the caller boot a fresh one
+            if stage == "RUNNING":
+                # RUNNING precedes "server ready" (the host still has to fetch + exec sbx-server),
+                # so discovery only adopts it once its server answers — keep polling until it does.
+                self._discover_hosts()
+                if any(host.job_id == pending.id for host in self._hosts):
+                    return True
+            time.sleep(1.0)
+        return False
+
+    def _discover_hosts(self) -> None:
+        """Attach to running host jobs that match this pool (image/flavor/name).
+
+        Lets `create()` reuse a host warmed by an earlier call or another process
+        instead of booting a new one. Hosts are found via job labels; each adopted
+        host's free capacity is read from the server, so packing stays accurate.
+        """
+        known = {host.job_id for host in self._hosts}
+        matches = [
+            job
+            for job in self._api.list_jobs(
+                status="RUNNING",
+                labels={MODE_LABEL: MODE_POOL, POOL_LABEL: self.name},
+                namespace=self._namespace,
+            )
+            if job.id not in known
+        ]
+
+        for job in matches:
+            server = None
+            try:
+                server = _connect_host(self._api, job.id, namespace=self._namespace)
+                # Capacity comes from the host's SBX_CAPACITY env; otherwise an adopted host
+                # would silently pack at the pool default and mis-pack.
+                env = _host_env(self._api, job, namespace=self._namespace)
+                server.capacity = int(env.get("SBX_CAPACITY", self.sandboxes_per_host))
+                server.live = len(server.request("GET", "/v1/sandboxes").json())
+            except (SandboxError, httpx.HTTPError, HfHubHTTPError) as e:
+                # Host died (e.g. deleted between list_jobs and inspect_job), is still starting
+                # up, or is unreachable: skip it, closing the client if one was opened.
+                logger.debug(f"Skipping host {job.id} during discovery: {e}")
+                if server is not None:
+                    server.close()
+                continue
+            with self._lock:
+                if any(host.job_id == job.id for host in self._hosts):
+                    server.close()  # adopted concurrently by another thread
+                else:
+                    self._hosts.append(server)
+
+    def _provision_hosts(self, num_new: int) -> List[_SandboxServer]:
+        """Boot `num_new` host jobs in parallel, respecting `max_hosts`."""
+        with self._lock:
+            current = len(self._hosts)
+        if self.max_hosts is not None and current + num_new > self.max_hosts:
+            allowed = self.max_hosts - current
+            raise SandboxError(
+                f"Pool needs {num_new} more host(s) but max_hosts={self.max_hosts} "
+                f"allows only {max(0, allowed)} more. Raise max_hosts or kill some sandboxes."
+            )
+        # Boot in parallel, but collect every result before re-raising: if one boot fails,
+        # the others may have already started billable host jobs, so cancel those instead of
+        # leaking them (executor.map would surface the first error and drop the rest).
+        with ThreadPoolExecutor(max_workers=min(num_new, 32)) as executor:
+            futures = [executor.submit(self._boot_host) for _ in range(num_new)]
+        booted: List[_SandboxServer] = []
+        error: Exception | None = None
+        for future in futures:
+            try:
+                booted.append(future.result())
+            except Exception as e:
+                error = e
+        if error is not None:
+            for server in booted:
+                try:
+                    server.cancel_job()
+                except Exception:
+                    pass
+                finally:
+                    server.close()
+            raise error
+        return booted
+
+    def _boot_host(self) -> _SandboxServer:
+        """Start one host job and wait until its server is ready."""
+        hf_token = _effective_token(self._api)
+        nonce = token_hex(16)
+        sandbox_token = _derive_sandbox_token(hf_token, nonce)
+        command, job_env, job_secrets, job_volumes = _bootstrap_job_spec(
+            self._api,
+            hf_token,
+            env=None,  # host job carries no user env; sandboxes get env per create request
+            secrets=None,
+            volumes=None,
+            idle_timeout=self._idle_timeout,
+            forward_hf_token=False,
+            sandbox_token=sandbox_token,
+        )
+        # Host mode: per-sandbox idle eviction + empty-host shutdown (vs the dedicated
+        # whole-job watchdog).
+        job_env["SBX_HOST_MODE"] = "1"
+        # Server-authoritative packing cap: the host refuses creates past this (the client
+        # then packs onto / boots another host). Avoids cross-process over-commit. Read
+        # back (with SBX_IDLE_TIMEOUT) by `connect()` to rebuild the pool — labels stay for
+        # filtering only.
+        job_env["SBX_CAPACITY"] = str(self.sandboxes_per_host)
+        # Persist the optional cost ceiling on the host too, so a later connect() (e.g. the CLI
+        # `pool create --max-hosts N` then `create --pool <id>` flow) rebuilds the cap instead of
+        # defaulting to unlimited and provisioning past it.
+        if self.max_hosts is not None:
+            job_env["SBX_MAX_HOSTS"] = str(self.max_hosts)
+        labels = {SANDBOX_LABEL: "1", MODE_LABEL: MODE_POOL, POOL_LABEL: self.name, NONCE_LABEL: nonce}
+        job = self._api.run_job(
+            image=self.image,
+            command=command,
+            env=job_env,
+            secrets=job_secrets,
+            flavor=self.flavor,
+            timeout=SANDBOX_MAX_LIFETIME,
+            labels=labels,
+            volumes=job_volumes or None,
+            expose=[SANDBOX_SERVER_PORT],
+            namespace=self._namespace,
+        )
+        server: "_SandboxServer | None" = None
+        try:
+            # from_job is inside the try: if it raises (e.g. the server port isn't exposed),
+            # the already-started host job must still be cancelled so it doesn't linger billing.
+            server = _SandboxServer.from_job(
+                job=job,
+                nonce=nonce,
+                sandbox_token=sandbox_token,
+                api=self._api,
+                max_connections=min(self.sandboxes_per_host + 8, 256),
+                capacity=self.sandboxes_per_host,
+            )
+            server.wait_ready(self._start_timeout)
+        except Exception:
+            try:
+                self._api.cancel_job(job_id=job.id, namespace=job.owner.name)
+            except Exception as e:
+                logger.warning(f"Failed to cancel sandbox host {job.id} after startup failure: {e}")
+            if server is not None:
+                server.close()
+            raise
+        return server
+
+    def _create_one(self, host: "_SandboxServer", env: dict[str, Any], idle_secs: int | None) -> "Sandbox | None":
+        """Create one sandbox on a reserved `host`. Returns the sandbox, or None to retry.
+
+        None means either the host filled up between our reservation and the create
+        (server-authoritative capacity — another client packed it, so we mark it full and
+        place the sandbox elsewhere) or a host rebuilt from the cache is gone/unreachable
+        (dropped and re-placed via discovery / a fresh boot).
+        """
+        body: dict[str, Any] = {"count": 1}
+        if idle_secs is not None:
+            body["idle_timeout_secs"] = idle_secs
+        if env:
+            body["env"] = env
+        try:
+            data = host.request("POST", "/v1/sandboxes", json=body).json()
+        except (SandboxError, httpx.HTTPError) as e:
+            if host.verified:
+                raise  # a host we booted/discovered this session failing is a real error
+            logger.debug(f"Dropping unreachable cached host {host.job_id}: {e}")
+            self._drop_host(host)
+            return None
+        host.verified = True  # it answered, so it's a real live host now
+        sandboxes = data.get("sandboxes") or []
+        if int(data.get("rejected", 0)) or not sandboxes:
+            with self._lock:
+                host.live = host.capacity  # the host is full; stop reserving it
+            return None
+        item = sandboxes[0]
+        sandbox = Sandbox(
+            id=f"{host.job_id}{SHARED_ID_SEP}{item['id']}",
+            server=host,
+            local_id=item["id"],
+            owns_sandbox=True,
+            owns_server=False,
+        )
+        sandbox._on_kill = self._on_sandbox_killed
+        return sandbox
+
+    def _on_sandbox_killed(self, sandbox: Sandbox) -> None:
+        """Free the packing slot of a shared sandbox that was killed."""
+        with self._lock:
+            sandbox._server.live = max(0, sandbox._server.live - 1)
+
+    def _drop_host(self, host: _SandboxServer) -> None:
+        """Forget a host found dead this session (and mark it for cache pruning)."""
+        with self._lock:
+            self._hosts = [h for h in self._hosts if h is not host]
+            self._dead_host_ids.add(host.job_id)
+        host.close()
+
+    # ------------------------------------------------------------------ cache (best effort)
+
+    def _seed_hosts_from_cache(self) -> None:
+        """Adopt the pool's cached hosts without any HTTP (rebuilt from cached URL + nonce).
+
+        Best-effort and unverified: each adopted host is confirmed on the first successful
+        request (and dropped on the first failure, see `_create_one`). Hosts the cache
+        believes are full are skipped — label discovery re-checks them with fresh counts if
+        the seeded ones don't satisfy the request, so a stale-full entry never blocks a create.
+        """
+        cache = read_pool_cache(self.name)
+        if cache is None:
+            return
+        hf_token = _effective_token(self._api)
+        with self._lock:
+            known = {host.job_id for host in self._hosts}
+            for ch in cache.hosts:
+                if ch.job_id in known or ch.live >= ch.capacity:
+                    continue
+                server = _SandboxServer(
+                    job_id=ch.job_id,
+                    owner=ch.owner,
+                    image=self.image,
+                    base_url=ch.base_url,
+                    nonce=ch.nonce,
+                    sandbox_token=_derive_sandbox_token(hf_token, ch.nonce),
+                    api=self._api,
+                    max_connections=min(self.sandboxes_per_host + 8, 256),
+                    capacity=ch.capacity,
+                )
+                server.live = ch.live
+                server.verified = False
+                self._hosts.append(server)
+
+    def _save_cache(self) -> None:
+        """Persist the pool config + current hosts (with their live counts) for next time."""
+        with self._lock:
+            hosts = [
+                CachedHost(
+                    job_id=host.job_id,
+                    owner=host.owner,
+                    base_url=host.base_url,
+                    nonce=host.nonce,
+                    capacity=host.capacity,
+                    live=host.live,
+                    updated_at=time.time(),
+                )
+                for host in self._hosts
+            ]
+            dead = set(self._dead_host_ids)
+        save_pool_cache(
+            self.name,
+            image=self.image,
+            flavor=self.flavor,
+            sandboxes_per_host=self.sandboxes_per_host,
+            max_hosts=self.max_hosts,
+            idle_timeout=_duration_to_secs(self._idle_timeout) if self._idle_timeout is not None else None,
+            namespace=self._namespace,
+            hosts=hosts,
+            dead_host_ids=dead,
+        )
+
+
+def _effective_token(api: HfApi) -> str:
+    token = api.token if isinstance(api.token, str) else get_token()
+    if not token:
+        raise SandboxError("A Hugging Face token is required to use sandboxes. Run `hf auth login` first.")
+    return token
+
+
+def _bootstrap_job_spec(
+    api: HfApi,
+    hf_token: str,
+    *,
+    env: dict[str, Any] | None,
+    secrets: dict[str, Any] | None,
+    volumes: List[Volume] | None,
+    idle_timeout: int | float | str | None,
+    forward_hf_token: bool,
+    sandbox_token: str,
+) -> tuple[list[str], dict[str, Any], dict[str, Any], List[Volume]]:
+    """Build the (command, env, secrets, volumes) to launch a job running sbx-server.
+
+    Shared by dedicated sandboxes and shared hosts: both fetch and exec the same unified
+    `sbx-server` binary at startup (via `/bin/sh`), downloading it with wget/curl, or
+    reading it off the always-mounted server bucket when the image ships neither.
+    """
+    # Reserved SBX_* keys go last so user-provided env/secrets can't override them
+    # (e.g. clobbering SBX_PORT would break the proxy, SBX_TOKEN would break auth).
+    job_env: dict[str, Any] = {**(env or {}), "SBX_PORT": str(SANDBOX_SERVER_PORT)}
+    job_secrets: dict[str, Any] = {**(secrets or {}), "SBX_TOKEN": sandbox_token}
+    job_volumes = list(volumes or [])
+    if idle_timeout is not None:
+        job_env["SBX_IDLE_TIMEOUT"] = str(_duration_to_secs(idle_timeout))
+    if forward_hf_token:
+        job_secrets["HF_TOKEN"] = hf_token
+
+    job_env["SBX_SERVER_URL"] = f"{api.endpoint}/buckets/{constants.SANDBOX_SERVER_BUCKET}/resolve/sbx-server"
+    job_secrets["SBX_DL_TOKEN"] = hf_token
+    # Always mount the server bucket as a transparent fallback for images without wget/curl.
+    # It's only read (paying the ~2-3s FUSE cost) when the bootstrap script can't download.
+    job_env["SBX_SERVER_MOUNT"] = _SERVER_MOUNT_PATH
+    job_volumes.append(
+        Volume(type="bucket", source=constants.SANDBOX_SERVER_BUCKET, mount_path=_SERVER_MOUNT_PATH, read_only=True)
+    )
+    command = ["/bin/sh", "-c", _BOOTSTRAP_DOWNLOAD]
+    return command, job_env, job_secrets, job_volumes
+
+
+def _host_env(api: HfApi, job: JobInfo, *, namespace: str | None) -> dict[str, Any]:
+    """Return a host job's env vars (where pool config lives)"""
+    env = job.environment if isinstance(job.environment, dict) else {}
+    if "SBX_CAPACITY" not in env:
+        env = api.inspect_job(job_id=job.id, namespace=namespace).environment or {}
+        env = env if isinstance(env, dict) else {}
+    return env
+
+
+def _find_pool_host_job(api: HfApi, pool_id: str, *, namespace: str | None = None) -> JobInfo:
+    """Return any running host job belonging to `pool_id` (found via the pool label)."""
+    for job in api.list_jobs(
+        status="RUNNING", labels={MODE_LABEL: MODE_POOL, POOL_LABEL: pool_id}, namespace=namespace
+    ):
+        return job
+    raise SandboxError(
+        f"No running host found for pool '{pool_id}'. The pool has stopped "
+        "(all its hosts were killed or idle-timed-out); create a new one."
+    )
+
+
+def _connect_host(api: HfApi, host_job_id: str, *, namespace: str | None = None) -> _SandboxServer:
+    """Reattach to a running host job and return its server transport."""
+    job = api.inspect_job(job_id=host_job_id, namespace=namespace)
+    labels = job.labels or {}
+    nonce = labels.get(NONCE_LABEL)
+    if nonce is None or labels.get(MODE_LABEL) != MODE_POOL:
+        raise SandboxError(f"Job {host_job_id} is not a sandbox host.")
+    if job.status.stage != "RUNNING":
+        raise SandboxError(f"Sandbox host {host_job_id} is not running (status: {job.status.stage}).")
+    return _SandboxServer.from_job(
+        job=job,
+        nonce=nonce,
+        sandbox_token=_derive_sandbox_token(_effective_token(api), nonce),
+        api=api,
+        max_connections=SandboxFiles.PARALLEL_MAX_WORKERS + 2,
+    )
+
+
+def _split_sandbox_id(sandbox_id: str, namespace: str | None) -> tuple[str, str | None]:
+    """Accept `namespace/sandbox_id` ids (as shown in the Hub UI), like `hf jobs` does."""
+    if "/" not in sandbox_id:
+        return sandbox_id, namespace
+    extracted_namespace, parsed_id = sandbox_id.split("/", 1)
+    if not extracted_namespace or not parsed_id or "/" in parsed_id:
+        raise SandboxError(f"Sandbox id must be 'sandbox_id' or 'namespace/sandbox_id', got {sandbox_id!r}.")
+    if namespace is not None and namespace != extracted_namespace:
+        raise SandboxError(
+            f"Conflicting namespace: got namespace={namespace!r} but sandbox id implies namespace={extracted_namespace!r}."
+        )
+    return parsed_id, extracted_namespace
+
+
+def _find_server_url(job: JobInfo) -> str:
+    for url in job.status.expose_urls or []:
+        if f"--{SANDBOX_SERVER_PORT}." in url:
+            return url
+    raise SandboxError(f"Job {job.id} does not expose the sandbox server port {SANDBOX_SERVER_PORT}.")
+
+
+def _tail_job_logs(api: HfApi, job_id: str, *, namespace: str | None = None, limit: int = 20) -> str:
+    try:
+        lines = list(api.fetch_job_logs(job_id=job_id, namespace=namespace))[-limit:]
+    except Exception:
+        return ""
+    return " Last logs:\n" + "\n".join(f"  {line}" for line in lines) if lines else ""

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_sandbox_cache.py

@@ -0,0 +1,159 @@
+# coding=utf-8
+# 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.
+"""Best-effort local cache for SandboxPool hosts (host/pool mode)."""
+
+import json
+import os
+import time
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import List
+
+from . import constants
+from .utils import WeakFileLock, logging
+
+
+logger = logging.get_logger(__name__)
+
+# Bump if the on-disk layout changes incompatibly; older/newer files are ignored on read.
+_CACHE_VERSION = 1
+
+# A write should never block a sandbox creation for long: the cache is best-effort, so we
+# rather skip persisting than wait on a stuck lock.
+_LOCK_TIMEOUT = 5.0
+
+
+@dataclass
+class CachedHost:
+    """A single host Job of a pool, as last seen by some process.
+
+    `base_url` + `nonce` are everything needed to rebuild the in-job server transport
+    (`_SandboxServer`) without an `inspect_job` round-trip: the per-sandbox auth token is
+    re-derived from the user's HF token and `nonce` (see `_derive_sandbox_token`).
+    """
+
+    job_id: str
+    owner: str  # namespace the host job runs under (for cancel/inspect)
+    base_url: str  # exposed sbx-server URL (does not change while the job lives)
+    nonce: str  # public nonce from the job label; derives the sandbox auth token
+    capacity: int  # SBX_CAPACITY: max sandboxes the host packs
+    live: int  # sandboxes last observed on the host (best-effort, may be stale)
+    updated_at: float = 0.0
+
+
+@dataclass
+class PoolCache:
+    """Cached view of one pool: its config (to boot new hosts) + its known hosts."""
+
+    pool_id: str
+    image: str
+    flavor: str
+    sandboxes_per_host: int
+    max_hosts: int | None
+    idle_timeout: int | None
+    namespace: str | None
+    hosts: List[CachedHost] = field(default_factory=list)
+    version: int = _CACHE_VERSION
+    updated_at: float = 0.0
+
+
+def _pools_dir() -> Path:
+    return Path(constants.HF_HOME) / "sandbox" / "pools"
+
+
+def pool_cache_path(pool_id: str) -> Path:
+    """Path of the cache file for `pool_id` (no I/O)."""
+    if any(c in pool_id for c in ("/", "\\", "\x00")) or pool_id in (".", ".."):
+        raise ValueError(f"Invalid pool id: {pool_id!r}")
+    return _pools_dir() / f"{pool_id}.json"
+
+
+def read_pool_cache(pool_id: str) -> PoolCache | None:
+    """Return the cached view of `pool_id`, or `None` if missing/corrupt/incompatible."""
+    try:
+        path = pool_cache_path(pool_id)
+        with path.open("r", encoding="utf-8") as f:
+            data = json.load(f)
+        if data.get("version") != _CACHE_VERSION:
+            return None
+        hosts = [CachedHost(**h) for h in data.pop("hosts", [])]
+        return PoolCache(**data, hosts=hosts)
+    except FileNotFoundError:
+        return None
+    except Exception as e:
+        logger.debug(f"Ignoring unreadable sandbox pool cache for {pool_id!r}: {e}")
+        return None
+
+
+def save_pool_cache(
+    pool_id: str,
+    *,
+    image: str,
+    flavor: str,
+    sandboxes_per_host: int,
+    max_hosts: int | None,
+    idle_timeout: int | None,
+    namespace: str | None,
+    hosts: List[CachedHost],
+    dead_host_ids: set[str] | None = None,
+) -> None:
+    """Merge `hosts` into the cache for `pool_id` (best-effort, never raises).
+
+    Concurrency-safe: under a file lock, the on-disk hosts are read, then `hosts` are
+    upserted by `job_id` and `dead_host_ids` removed, so a process only adds/updates what
+    it learned and never drops hosts another process discovered. The result is written
+    atomically. The pool config is refreshed from the arguments.
+    """
+    dead = dead_host_ids or set()
+    try:
+        path = pool_cache_path(pool_id)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with WeakFileLock(str(path) + ".lock", timeout=_LOCK_TIMEOUT):
+            existing = read_pool_cache(pool_id)
+            merged = {h.job_id: h for h in (existing.hosts if existing else [])}
+            for host in hosts:
+                merged[host.job_id] = host
+            for job_id in dead:
+                merged.pop(job_id, None)
+            cache = PoolCache(
+                pool_id=pool_id,
+                image=image,
+                flavor=flavor,
+                sandboxes_per_host=sandboxes_per_host,
+                max_hosts=max_hosts,
+                idle_timeout=idle_timeout,
+                namespace=namespace,
+                hosts=list(merged.values()),
+                updated_at=time.time(),
+            )
+            _atomic_write(path, cache)
+    except Exception as e:
+        logger.debug(f"Could not write sandbox pool cache for {pool_id!r}: {e}")
+
+
+def delete_pool_cache(pool_id: str) -> None:
+    """Remove the cache file for `pool_id` (best-effort, never raises)."""
+    try:
+        pool_cache_path(pool_id).unlink(missing_ok=True)
+    except Exception as e:
+        logger.debug(f"Could not delete sandbox pool cache for {pool_id}: {e}")
+
+
+def _atomic_write(path: Path, cache: PoolCache) -> None:
+    """Write the cache via a temp file + `os.replace` so readers never see a partial file."""
+    tmp = path.parent / f"{path.name}.{os.getpid()}.tmp"
+    with tmp.open("w", encoding="utf-8") as f:
+        json.dump(asdict(cache), f, indent=2)
+    os.replace(tmp, path)

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_snapshot_download.py

@@ -0,0 +1,681 @@
+import os
+from pathlib import Path
+from typing import Literal, overload
+
+import httpx
+from tqdm.auto import tqdm as base_tqdm
+from tqdm.contrib.concurrent import thread_map
+
+from . import constants
+from ._tree_cache import TreeCacheEntry, read_tree_cache, tree_cache_folder_for_local_dir, write_tree_cache
+from .errors import (
+    CachedRepoTreeNotFoundError,
+    DryRunError,
+    GatedRepoError,
+    HfHubHTTPError,
+    IncompleteSnapshotError,
+    LocalEntryNotFoundError,
+    RepositoryNotFoundError,
+    RevisionNotFoundError,
+)
+from .file_download import REGEX_COMMIT_HASH, DryRunFileInfo, hf_hub_download, repo_folder_name
+from .hf_api import DatasetInfo, HfApi, KernelInfo, ModelInfo, RepoFile, SpaceInfo
+from .utils import OfflineModeIsEnabled, filter_repo_objects, logging, validate_hf_hub_args
+from .utils._xet_progress_reporting import (
+    XET_BYTES_BAR_FORMAT,
+    XET_TRANSFER_BAR_FORMAT,
+    _finish_transfer_bar,
+    _update_transfer_bar,
+)
+from .utils.tqdm import _create_progress_bar
+from .utils.tqdm import tqdm as hf_tqdm
+
+
+logger = logging.get_logger(__name__)
+
+
+@overload
+def snapshot_download(
+    repo_id: str,
+    *,
+    repo_type: str | None = None,
+    revision: str | None = None,
+    cache_dir: str | Path | None = None,
+    local_dir: str | Path | None = None,
+    library_name: str | None = None,
+    library_version: str | None = None,
+    user_agent: dict | str | None = None,
+    etag_timeout: float = constants.DEFAULT_ETAG_TIMEOUT,
+    force_download: bool = False,
+    token: bool | str | None = None,
+    local_files_only: bool = False,
+    allow_patterns: list[str] | str | None = None,
+    ignore_patterns: list[str] | str | None = None,
+    max_workers: int = 8,
+    tqdm_class: type[base_tqdm] | None = None,
+    headers: dict[str, str] | None = None,
+    endpoint: str | None = None,
+    dry_run: Literal[False] = False,
+) -> str: ...
+
+
+@overload
+def snapshot_download(
+    repo_id: str,
+    *,
+    repo_type: str | None = None,
+    revision: str | None = None,
+    cache_dir: str | Path | None = None,
+    local_dir: str | Path | None = None,
+    library_name: str | None = None,
+    library_version: str | None = None,
+    user_agent: dict | str | None = None,
+    etag_timeout: float = constants.DEFAULT_ETAG_TIMEOUT,
+    force_download: bool = False,
+    token: bool | str | None = None,
+    local_files_only: bool = False,
+    allow_patterns: list[str] | str | None = None,
+    ignore_patterns: list[str] | str | None = None,
+    max_workers: int = 8,
+    tqdm_class: type[base_tqdm] | None = None,
+    headers: dict[str, str] | None = None,
+    endpoint: str | None = None,
+    dry_run: Literal[True] = True,
+) -> list[DryRunFileInfo]: ...
+
+
+@overload
+def snapshot_download(
+    repo_id: str,
+    *,
+    repo_type: str | None = None,
+    revision: str | None = None,
+    cache_dir: str | Path | None = None,
+    local_dir: str | Path | None = None,
+    library_name: str | None = None,
+    library_version: str | None = None,
+    user_agent: dict | str | None = None,
+    etag_timeout: float = constants.DEFAULT_ETAG_TIMEOUT,
+    force_download: bool = False,
+    token: bool | str | None = None,
+    local_files_only: bool = False,
+    allow_patterns: list[str] | str | None = None,
+    ignore_patterns: list[str] | str | None = None,
+    max_workers: int = 8,
+    tqdm_class: type[base_tqdm] | None = None,
+    headers: dict[str, str] | None = None,
+    endpoint: str | None = None,
+    dry_run: bool = False,
+) -> str | list[DryRunFileInfo]: ...
+
+
+@validate_hf_hub_args
+def snapshot_download(
+    repo_id: str,
+    *,
+    repo_type: str | None = None,
+    revision: str | None = None,
+    cache_dir: str | Path | None = None,
+    local_dir: str | Path | None = None,
+    library_name: str | None = None,
+    library_version: str | None = None,
+    user_agent: dict | str | None = None,
+    etag_timeout: float = constants.DEFAULT_ETAG_TIMEOUT,
+    force_download: bool = False,
+    token: bool | str | None = None,
+    local_files_only: bool = False,
+    allow_patterns: list[str] | str | None = None,
+    ignore_patterns: list[str] | str | None = None,
+    max_workers: int = 8,
+    tqdm_class: type[base_tqdm] | None = None,
+    headers: dict[str, str] | None = None,
+    endpoint: str | None = None,
+    dry_run: bool = False,
+) -> str | list[DryRunFileInfo]:
+    """Download repo files.
+
+    Download a whole snapshot of a repo's files at the specified revision. This is useful when you want all files from
+    a repo because you don't know which ones you will need _a priori_. All files are nested in a folder to keep their
+    path and filename relative to that folder. You can also filter which files to download by using `allow_patterns`
+    and `ignore_patterns`.
+
+    If `local_dir` is provided, the file structure from the repo will be replicated in this location. When using this
+    option, the `cache_dir` will not be used, and a `.cache/huggingface/` folder will be created at the root of `local_dir`
+    to store some metadata related to the downloaded files. While this mechanism is not as robust as the main
+    cache system, it's optimized for regularly pulling the latest version of a repository.
+
+    An alternative would be to clone the repo, but this requires git and git-lfs to be installed and properly
+    configured. It is also not possible to filter which files to download when cloning a repository using git.
+
+    Args:
+        repo_id (`str`):
+            A user or an organization name and a repo name separated by a `/`.
+        repo_type (`str`, *optional*):
+            Set to `"dataset"`, `"space"` or `"kernel"` if downloading from a dataset, space or kernel repo,
+            `None` or `"model"` if downloading from a model. Default is `None`.
+        revision (`str`, *optional*):
+            An optional Git revision id, which can be a branch name, a tag, or a
+            commit hash.
+        cache_dir (`str`, `Path`, *optional*):
+            Path to the folder where cached files are stored.
+        local_dir (`str` or `Path`, *optional*):
+            If provided, the downloaded files will be placed under this directory.
+        library_name (`str`, *optional*):
+            The name of the library to which the object corresponds.
+        library_version (`str`, *optional*):
+            The version of the library.
+        user_agent (`str`, `dict`, *optional*):
+            The user-agent info in the form of a dictionary or a string.
+        etag_timeout (`float`, *optional*, defaults to `10`):
+            When fetching ETag, how many seconds to wait for the server to send
+            data before giving up, which is passed to `httpx.request`.
+        force_download (`bool`, *optional*, defaults to `False`):
+            Whether the file should be downloaded even if it already exists in the local cache.
+        token (`str`, `bool`, *optional*):
+            A token to be used for the download.
+                - If `True`, the token is read from the HuggingFace config
+                  folder.
+                - If a string, it's used as the authentication token.
+        headers (`dict`, *optional*):
+            Additional headers to include in the request. Those headers take precedence over the others.
+        endpoint (`str`, *optional*):
+            The Hub endpoint to send the request to. Defaults to the value of `HF_ENDPOINT`.
+        local_files_only (`bool`, *optional*, defaults to `False`):
+            If `True`, do not download any files even if they are not in `cache_dir` or `local_dir`.
+        allow_patterns (`list[str]` or `str`, *optional*):
+            If provided, only files matching at least one pattern are downloaded.
+        ignore_patterns (`list[str]` or `str`, *optional*):
+            If provided, files matching any of the patterns are not downloaded.
+        max_workers (`int`, *optional*):
+            Number of concurrent threads to download files (1 thread = 1 file download).
+            Defaults to 8.
+        tqdm_class (`tqdm`, *optional*):
+            If provided, overwrites the default behavior for the progress bar. Passed
+            argument must inherit from `tqdm.auto.tqdm` or at least mimic its behavior.
+            Note that the `tqdm_class` is not passed to each individual download.
+            Defaults to the custom HF progress bar that can be disabled by setting
+            `HF_HUB_DISABLE_PROGRESS_BARS` environment variable.
+        dry_run (`bool`, *optional*, defaults to `False`):
+            If `True`, perform a dry run without actually downloading the files. Returns a list of
+            [`DryRunFileInfo`] objects containing information about what would be downloaded.
+
+    Returns:
+        `str` or list of [`DryRunFileInfo`]:
+            - If `dry_run=False`: Local snapshot path.
+            - If `dry_run=True`: A list of [`DryRunFileInfo`] objects containing download information.
+
+    Raises:
+        [`~utils.RepositoryNotFoundError`]
+            If the repository to download from cannot be found. This may be because it doesn't exist
+            or because it is set to `private` and you do not have access.
+        [`~utils.RevisionNotFoundError`]
+            If the revision to download from cannot be found.
+        [`~errors.IncompleteSnapshotError`]
+            If the Hub cannot be reached (offline, connection issue, or `local_files_only=True`) and the
+            cached snapshot is missing some of the requested files.
+        [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+            If `token=True` and the token cannot be found.
+        [`OSError`](https://docs.python.org/3/library/exceptions.html#OSError) if
+            ETag cannot be determined.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If some parameter value is invalid.
+    """
+    if cache_dir is None:
+        cache_dir = constants.HF_HUB_CACHE
+    cache_dir = str(Path(cache_dir).expanduser().resolve())
+    if local_dir is not None:
+        local_dir = str(Path(local_dir).expanduser().resolve())
+    if revision is None:
+        revision = constants.DEFAULT_REVISION
+
+    if repo_type is None:
+        repo_type = "model"
+    if repo_type not in constants.REPO_TYPES_WITH_KERNEL:
+        raise ValueError(
+            f"Invalid repo type: {repo_type}. Accepted repo types are: {str(constants.REPO_TYPES_WITH_KERNEL)}"
+        )
+
+    storage_folder = os.path.join(cache_dir, repo_folder_name(repo_id=repo_id, repo_type=repo_type))
+
+    # Folder under which the per-commit tree listing (`trees/<commit_hash>.json`) is cached on disk.
+    tree_cache_folder = tree_cache_folder_for_local_dir(local_dir) if local_dir is not None else storage_folder
+
+    api = HfApi(
+        library_name=library_name,
+        library_version=library_version,
+        user_agent=user_agent,
+        endpoint=endpoint,
+        headers=headers,
+        token=token,
+    )
+
+    repo_info: ModelInfo | DatasetInfo | SpaceInfo | KernelInfo | None = None
+    api_call_error: Exception | None = None
+    if not local_files_only:
+        # try/except logic to handle different errors => taken from `hf_hub_download`
+        try:
+            # if we have internet connection we want to list files to download
+            repo_info = api.repo_info(repo_id=repo_id, repo_type=repo_type, revision=revision)
+        except httpx.ProxyError:
+            # Actually raise on proxy error
+            raise
+        except (httpx.ConnectError, httpx.TimeoutException, OfflineModeIsEnabled) as error:
+            # Internet connection is down
+            # => will try to use local files only
+            api_call_error = error
+            pass
+        except RevisionNotFoundError:
+            # The repo was found but the revision doesn't exist on the Hub (never existed or got deleted)
+            raise
+        except HfHubHTTPError as error:
+            # Multiple reasons for an http error:
+            # - Repository is private and invalid/missing token sent
+            # - Repository is gated and invalid/missing token sent
+            # - Hub is down (error 500 or 504)
+            # => let's switch to 'local_files_only=True' to check if the files are already cached.
+            #    (if it's not the case, the error will be re-raised)
+            api_call_error = error
+            pass
+
+    # At this stage, if `repo_info` is None it means either:
+    # - internet connection is down
+    # - internet connection is deactivated (local_files_only=True or HF_HUB_OFFLINE=True)
+    # - repo is private/gated and invalid/missing token sent
+    # - Hub is down
+    # => let's look if we can find the appropriate folder in the cache:
+    #    - if the specified revision is a commit hash, look inside "snapshots".
+    #    - f the specified revision is a branch or tag, look inside "refs".
+    # => if local_dir is not None, we will return the path to the local folder if it exists.
+    if repo_info is None:
+        if dry_run:
+            raise DryRunError(
+                "Dry run cannot be performed as the repository cannot be accessed. Please check your internet connection or authentication token."
+            ) from api_call_error
+
+        # Try to get which commit hash corresponds to the specified revision
+        commit_hash = None
+        if REGEX_COMMIT_HASH.match(revision):
+            commit_hash = revision
+        else:
+            ref_path = os.path.join(storage_folder, "refs", revision)
+            if os.path.exists(ref_path):
+                # retrieve commit_hash from refs file
+                with open(ref_path) as f:
+                    commit_hash = f.read()
+
+        # Try to locate snapshot folder for this commit hash
+        if commit_hash is not None and local_dir is None:
+            snapshot_folder = os.path.join(storage_folder, "snapshots", commit_hash)
+            if os.path.exists(snapshot_folder):
+                # The folder exists, but may be partial (e.g. after an interrupted download): only return it
+                # if the cached tree listing confirms it is complete.
+                _raise_if_incomplete_snapshot(
+                    tree_cache_folder=tree_cache_folder,
+                    commit_hash=commit_hash,
+                    base_dir=snapshot_folder,
+                    allow_patterns=allow_patterns,
+                    ignore_patterns=ignore_patterns,
+                    repo_id=repo_id,
+                    revision=revision,
+                    api_call_error=api_call_error,
+                )
+                return snapshot_folder
+
+        # If local_dir is not None, return it if it exists and is complete
+        if local_dir is not None:
+            local_dir = Path(local_dir)
+            if local_dir.is_dir() and any(local_dir.iterdir()):
+                if commit_hash is not None:
+                    _raise_if_incomplete_snapshot(
+                        tree_cache_folder=tree_cache_folder,
+                        commit_hash=commit_hash,
+                        base_dir=str(local_dir),
+                        allow_patterns=allow_patterns,
+                        ignore_patterns=ignore_patterns,
+                        repo_id=repo_id,
+                        revision=revision,
+                        api_call_error=api_call_error,
+                    )
+                logger.warning(
+                    f"Returning existing local_dir `{local_dir}` as remote repo cannot be accessed in `snapshot_download` ({api_call_error})."
+                )
+                return str(local_dir.resolve())
+        # If we couldn't find the appropriate folder on disk, raise an error.
+        if local_files_only:
+            raise LocalEntryNotFoundError(
+                "Cannot find an appropriate cached snapshot folder for the specified revision on the local disk and "
+                "outgoing traffic has been disabled. To enable repo look-ups and downloads online, pass "
+                "'local_files_only=False' as input."
+            )
+        elif isinstance(api_call_error, OfflineModeIsEnabled):
+            raise LocalEntryNotFoundError(
+                "Cannot find an appropriate cached snapshot folder for the specified revision on the local disk and "
+                "outgoing traffic has been disabled. To enable repo look-ups and downloads online, set "
+                "'HF_HUB_OFFLINE=0' as environment variable."
+            ) from api_call_error
+        elif isinstance(api_call_error, (RepositoryNotFoundError, GatedRepoError)) or (
+            isinstance(api_call_error, HfHubHTTPError) and api_call_error.response.status_code == 401
+        ):
+            # Repo not found, gated, or specific authentication error => let's raise the actual error
+            raise api_call_error
+        else:
+            # Otherwise: most likely a connection issue or Hub downtime => let's warn the user
+            raise LocalEntryNotFoundError(
+                f"Got: {api_call_error.__class__.__name__}: {api_call_error}"
+                "\nAn error happened while trying to locate the files on the Hub, and we cannot find the appropriate"
+                " snapshot folder for the specified revision on the local disk. Please check your internet connection"
+                " and try again."
+            ) from api_call_error
+
+    # At this stage, internet connection is up and running
+    # => let's download the files!
+    assert repo_info.sha is not None, "Repo info returned from server must have a revision sha."
+    commit_hash = repo_info.sha
+
+    # Retrieve /tree listing from cache or fetch it
+    tree_entries = read_tree_cache(tree_cache_folder, commit_hash)
+    if tree_entries is None:
+        tree_entries = {
+            f.path: TreeCacheEntry(
+                size=f.size,
+                blob_id=f.blob_id,
+                lfs_sha256=f.lfs.sha256 if f.lfs is not None else None,
+                lfs_size=f.lfs.size if f.lfs is not None else None,
+                xet_hash=f.xet_hash,
+            )
+            for f in api.list_repo_tree(repo_id=repo_id, recursive=True, revision=commit_hash, repo_type=repo_type)
+            if isinstance(f, RepoFile)
+        }
+        if not dry_run:
+            write_tree_cache(tree_cache_folder, commit_hash, tree_entries)
+
+    filtered_repo_files = list(
+        filter_repo_objects(
+            items=tree_entries.keys(),
+            allow_patterns=allow_patterns,
+            ignore_patterns=ignore_patterns,
+        )
+    )
+    tqdm_desc = f"Fetching {len(filtered_repo_files)} files"
+    if dry_run:
+        tqdm_desc = "[dry-run] " + tqdm_desc
+
+    snapshot_folder = os.path.join(storage_folder, "snapshots", commit_hash)
+    # if passed revision is not identical to commit_hash
+    # then revision has to be a branch name or tag name.
+    # In that case store a ref.
+    if revision != commit_hash:
+        ref_path = os.path.join(storage_folder, "refs", revision)
+        try:
+            os.makedirs(os.path.dirname(ref_path), exist_ok=True)
+            with open(ref_path, "w") as f:
+                f.write(commit_hash)
+        except OSError as e:
+            logger.warning(f"Ignored error while writing commit hash to {ref_path}: {e}.")
+
+    results: list[str | DryRunFileInfo] = []
+
+    # User can use its own tqdm class or the default one from `huggingface_hub.utils`
+    tqdm_class = tqdm_class or hf_tqdm
+
+    # Create progress bars for the bytes downloaded.
+    # Transfer bytes are received from the network; reconstruction bytes are written to disk.
+    transfer_progress = _create_progress_bar(
+        cls=tqdm_class,
+        log_level=logger.getEffectiveLevel(),
+        name="huggingface_hub.snapshot_download.transfer",
+        desc="Downloading bytes",
+        total=0,
+        initial=0,
+        unit="B",
+        unit_scale=True,
+        bar_format=XET_TRANSFER_BAR_FORMAT,
+    )
+
+    reconstruct_progress = _create_progress_bar(
+        cls=tqdm_class,
+        log_level=logger.getEffectiveLevel(),
+        name="huggingface_hub.snapshot_download",
+        desc="Reconstructing (incomplete total...)",
+        total=0,
+        initial=0,
+        unit="B",
+        unit_scale=True,
+        bar_format=XET_BYTES_BAR_FORMAT,
+    )
+
+    class _AggregatedTqdm:
+        """Fake tqdm object to aggregate progress into the parent snapshot progress bars.
+
+        In practice, the `_AggregatedTqdm` object won't be displayed; it's just used to update
+        the `reconstruct_progress` and `transfer_progress` bars from each thread/file download.
+        """
+
+        def __init__(self, *args, **kwargs):
+            # Adjust the total of the parent progress bar
+            total = kwargs.pop("total", None)
+            if total is not None:
+                reconstruct_progress.total = (reconstruct_progress.total or 0) + total
+                transfer_progress.total = (transfer_progress.total or 0) + total
+                reconstruct_progress.refresh()
+
+            # Adjust initial of the parent progress bar
+            initial = kwargs.pop("initial", 0)
+            if initial:
+                reconstruct_progress.update(initial)
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc_value, traceback):
+            pass
+
+        def close(self) -> None:
+            pass
+
+        def update(self, n: int | float | None = 1) -> None:
+            reconstruct_progress.update(n)
+
+        def update_transfer(self, n: int | float | None = 1) -> None:
+            _update_transfer_bar(transfer_progress, int(n or 0))
+
+        def set_postfix_str(self, postfix: str, refresh: bool = False) -> None:
+            reconstruct_progress.set_postfix_str(postfix, refresh=refresh)
+
+        def set_transfer_postfix_str(self, postfix: str, refresh: bool = False) -> None:
+            transfer_progress.set_postfix_str(postfix, refresh=refresh)
+
+    # Pass the commit_hash as revision to hf_hub_download to skip network call if:
+    # - file is cached
+    # - or xet file with metadata cached in /tree cache
+    def _inner_hf_hub_download(repo_file: str) -> None:
+        results.append(
+            hf_hub_download(  # type: ignore
+                repo_id,
+                filename=repo_file,
+                repo_type=repo_type,
+                revision=commit_hash,
+                endpoint=endpoint,
+                cache_dir=cache_dir,
+                local_dir=local_dir,
+                library_name=library_name,
+                library_version=library_version,
+                user_agent=user_agent,
+                etag_timeout=etag_timeout,
+                force_download=force_download,
+                token=token,
+                headers=headers,
+                tqdm_class=_AggregatedTqdm,  # type: ignore
+                dry_run=dry_run,
+            )
+        )
+
+    thread_map(
+        _inner_hf_hub_download,
+        filtered_repo_files,
+        desc=tqdm_desc,
+        max_workers=max_workers,
+        tqdm_class=tqdm_class,
+    )
+
+    _finish_transfer_bar(transfer_progress)
+    transfer_progress.set_description("Download complete")
+    reconstruct_progress.set_description("Reconstruction complete")
+
+    if dry_run:
+        assert all(isinstance(r, DryRunFileInfo) for r in results)
+        return results  # type: ignore
+
+    if local_dir is not None:
+        return str(os.path.realpath(local_dir))
+    return snapshot_folder
+
+
+def _raise_if_incomplete_snapshot(
+    *,
+    tree_cache_folder: str,
+    commit_hash: str,
+    base_dir: str,
+    allow_patterns: list[str] | str | None,
+    ignore_patterns: list[str] | str | None,
+    repo_id: str,
+    revision: str,
+    api_call_error: Exception | None,
+) -> None:
+    """Raise [`IncompleteSnapshotError`] if the cached tree listing shows `base_dir` misses requested files.
+
+    If the tree listing is not cached we cannot tell, so we do nothing and the caller keeps returning the
+    folder as-is. Otherwise every expected file (after pattern filtering) must exist under `base_dir`.
+    """
+    tree_entries = read_tree_cache(tree_cache_folder, commit_hash)
+    if tree_entries is None:
+        return
+    expected = filter_repo_objects(
+        items=tree_entries.keys(), allow_patterns=allow_patterns, ignore_patterns=ignore_patterns
+    )
+    missing = [path for path in expected if not _local_file_exists(base_dir, path)]
+    if not missing:
+        return
+
+    sample = ", ".join(missing[:3])
+    if len(missing) > 3:
+        sample += f", ... ({len(missing) - 3} more)"
+    if api_call_error is not None:
+        reason = f"The Hub could not be reached ({api_call_error.__class__.__name__}: {api_call_error})."
+    else:
+        reason = "Outgoing traffic is disabled ('local_files_only=True')."
+    raise IncompleteSnapshotError(
+        f"The cached snapshot for '{repo_id}' (revision '{revision}', commit {commit_hash}) is incomplete: "
+        f"{len(missing)} file(s) are missing ({sample}). {reason} Re-run the download with network access "
+        "to complete the snapshot.",
+        snapshot_path=base_dir,
+    ) from api_call_error
+
+
+@validate_hf_hub_args
+def get_cached_repo_tree(
+    repo_id: str,
+    *,
+    repo_type: str | None = None,
+    revision: str | None = None,
+    cache_dir: str | Path | None = None,
+    local_dir: str | Path | None = None,
+) -> list[RepoFile]:
+    """Return the cached tree listing of a repo at a given revision, without any network call.
+
+    The tree listing is the set of files (with their download metadata) of a repo at a commit. It is populated
+    on disk as a side effect of [`snapshot_download`] (see the `trees/<commit_hash>.json` cache files) and is
+    used to skip network calls on subsequent downloads. This function exposes that cache directly.
+
+    If you need the current tree listing of a repo on the Hub, use [`list_repo_tree`] instead.
+
+    Args:
+        repo_id (`str`):
+            A user or an organization name and a repo name separated by a `/`.
+        repo_type (`str`, *optional*):
+            Set to `"dataset"`, `"space"` or `"kernel"` if listing from a dataset, space or kernel repo,
+            `None` or `"model"` if listing from a model. Default is `None`.
+        revision (`str`, *optional*):
+            An optional Git revision id, which can be a branch name, a tag, or a commit hash. Defaults to the
+            default branch. Branch/tag names are resolved to a commit hash using the local cache (`refs/`).
+        cache_dir (`str`, `Path`, *optional*):
+            Path to the folder where cached files are stored. Defaults to the value of `HF_HUB_CACHE`.
+        local_dir (`str` or `Path`, *optional*):
+            If provided, read the tree listing cached by a `local_dir` download (from
+            `local_dir/.cache/huggingface/`) instead of the main cache. Branch/tag revisions are still resolved
+            to a commit hash using the main cache (`cache_dir`).
+
+    Returns:
+        `list[RepoFile]`: The list of [`RepoFile`] objects cached for this revision.
+
+    Raises:
+        [`~errors.CachedRepoTreeNotFoundError`]
+            If no tree listing is cached for the requested revision (e.g. the repo was never downloaded at this revision).
+
+    Example:
+        ```py
+        >>> from huggingface_hub import get_cached_repo_tree
+        >>> files = get_cached_repo_tree("openai-community/gpt2")
+        >>> [f.path for f in files]
+        ['.gitattributes', 'config.json', 'model.safetensors', ...]
+        ```
+    """
+    if cache_dir is None:
+        cache_dir = constants.HF_HUB_CACHE
+    cache_dir = str(Path(cache_dir).expanduser().resolve())
+    if local_dir is not None:
+        local_dir = str(Path(local_dir).expanduser().resolve())
+    if revision is None:
+        revision = constants.DEFAULT_REVISION
+    if repo_type is None:
+        repo_type = constants.REPO_TYPE_MODEL
+    if repo_type not in constants.REPO_TYPES_WITH_KERNEL:
+        raise ValueError(
+            f"Invalid repo type: {repo_type}. Accepted repo types are: {str(constants.REPO_TYPES_WITH_KERNEL)}"
+        )
+
+    storage_folder = os.path.join(cache_dir, repo_folder_name(repo_id=repo_id, repo_type=repo_type))
+
+    # For `local_dir` downloads the tree listing lives under `local_dir/.cache/huggingface/`; otherwise it lives
+    # in the per-repo `storage_folder`. Refs are always recorded in the main cache, so we resolve them there.
+    tree_cache_folder = tree_cache_folder_for_local_dir(local_dir) if local_dir is not None else storage_folder
+
+    # The tree cache is keyed by commit hash. Resolve the revision to a commit hash: either it already is one,
+    # or it's a branch/tag name recorded in `refs/` by a previous download.
+    if REGEX_COMMIT_HASH.match(revision):
+        commit_hash = revision
+    else:
+        ref_path = os.path.join(storage_folder, "refs", revision)
+        if not os.path.isfile(ref_path):
+            raise CachedRepoTreeNotFoundError(
+                f"No cached tree listing found for '{repo_id}' (revision '{revision}', repo_type '{repo_type}'): "
+                f"the revision is not a commit hash and no matching ref is cached in '{storage_folder}'. "
+                "Download the repo (e.g. with `snapshot_download`) to populate the cache first."
+            )
+        with open(ref_path) as f:
+            commit_hash = f.read()
+
+    tree_entries = read_tree_cache(tree_cache_folder, commit_hash)
+    if tree_entries is None:
+        raise CachedRepoTreeNotFoundError(
+            f"No cached tree listing found for '{repo_id}' (revision '{revision}', commit '{commit_hash}', "
+            f"repo_type '{repo_type}') in '{tree_cache_folder}'. Download the repo (e.g. with `snapshot_download`) "
+            "to populate the cache first."
+        )
+
+    return [
+        RepoFile(path=path, size=entry.size, oid=entry.blob_id, xetHash=entry.xet_hash)
+        for path, entry in tree_entries.items()
+    ]
+
+
+def _local_file_exists(base_dir: str, path: str) -> bool:
+    """Check whether a repo file (path relative to `base_dir`, '/'-separated) exists on disk.
+
+    On Windows, paths longer than 255 characters must be prefixed with `\\\\?\\`, otherwise `os.path.isfile` reports an
+    existing file as missing.
+    """
+    full_path = os.path.join(base_dir, *path.split("/"))
+    if os.name == "nt" and len(os.path.abspath(full_path)) > 255 and not full_path.startswith("\\\\?\\"):
+        full_path = "\\\\?\\" + os.path.abspath(full_path)
+    return os.path.isfile(full_path)

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_space_api.py

@@ -0,0 +1,395 @@
+# Copyright 2019-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.
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import Literal
+
+from huggingface_hub.utils import HfMount, HfUri, parse_datetime
+
+
+class SpaceStage(str, Enum):
+    """
+    Enumeration of possible stage of a Space on the Hub.
+
+    Value can be compared to a string:
+    ```py
+    assert SpaceStage.BUILDING == "BUILDING"
+    ```
+
+    Taken from https://github.com/huggingface/moon-landing/blob/main/server/repo_types/SpaceInfo.ts#L61 (private url).
+    """
+
+    # Copied from moon-landing > server > repo_types > SpaceInfo.ts (private repo)
+    NO_APP_FILE = "NO_APP_FILE"
+    CONFIG_ERROR = "CONFIG_ERROR"
+    BUILDING = "BUILDING"
+    BUILD_ERROR = "BUILD_ERROR"
+    RUNNING = "RUNNING"
+    RUNNING_BUILDING = "RUNNING_BUILDING"
+    RUNTIME_ERROR = "RUNTIME_ERROR"
+    DELETING = "DELETING"
+    STOPPED = "STOPPED"
+    PAUSED = "PAUSED"
+    APP_STARTING = "APP_STARTING"
+    RUNNING_APP_STARTING = "RUNNING_APP_STARTING"
+
+
+INTERMEDIATE_SPACE_STAGES = (
+    SpaceStage.BUILDING,
+    SpaceStage.RUNNING_BUILDING,
+    SpaceStage.APP_STARTING,
+    SpaceStage.RUNNING_APP_STARTING,
+)
+
+TERMINAL_SPACE_STAGES = (
+    SpaceStage.RUNNING,
+    SpaceStage.BUILD_ERROR,
+    SpaceStage.RUNTIME_ERROR,
+    SpaceStage.CONFIG_ERROR,
+    SpaceStage.NO_APP_FILE,
+    SpaceStage.STOPPED,
+    SpaceStage.PAUSED,
+    SpaceStage.DELETING,
+)
+
+
+class SpaceHardware(str, Enum):
+    """
+    Enumeration of hardwares available to run your Space on the Hub.
+
+    Value can be compared to a string:
+    ```py
+    assert SpaceHardware.CPU_BASIC == "cpu-basic"
+    ```
+
+    Taken from https://github.com/huggingface-internal/moon-landing/blob/main/server/repo_types/SpaceHardwareFlavor.ts (private url).
+    """
+
+    # CPU
+    CPU_BASIC = "cpu-basic"
+    CPU_UPGRADE = "cpu-upgrade"
+
+    # ZeroGPU
+    ZERO_A10G = "zero-a10g"
+
+    # GPU
+    T4_SMALL = "t4-small"
+    T4_MEDIUM = "t4-medium"
+    L4X1 = "l4x1"
+    L4X4 = "l4x4"
+    L40SX1 = "l40sx1"
+    L40SX4 = "l40sx4"
+    L40SX8 = "l40sx8"
+    A10G_SMALL = "a10g-small"
+    A10G_LARGE = "a10g-large"
+    A10G_LARGEX2 = "a10g-largex2"
+    A10G_LARGEX4 = "a10g-largex4"
+    A100_LARGE = "a100-large"
+    A100X4 = "a100x4"
+    A100X8 = "a100x8"
+
+
+class SpaceStorage(str, Enum):
+    """
+    Enumeration of persistent storage available for your Space on the Hub.
+
+    Value can be compared to a string:
+    ```py
+    assert SpaceStorage.SMALL == "small"
+    ```
+
+    Taken from https://github.com/huggingface/moon-landing/blob/main/server/repo_types/SpaceHardwareFlavor.ts#L24 (private url).
+    """
+
+    SMALL = "small"
+    MEDIUM = "medium"
+    LARGE = "large"
+
+
+@dataclass
+class Volume:
+    """
+    Describes a volume to mount in a Space or Job container.
+
+    Args:
+        type (`str`):
+            Type of volume: `"bucket"`, `"model"`, `"dataset"`, or `"space"`.
+        source (`str`):
+            Source identifier, e.g. `"username/my-bucket"` or `"username/my-model"`.
+        mount_path (`str`):
+            Mount path inside the container, e.g. `"/data"`. Must start with `/`.
+        revision (`str` or `None`):
+            Git revision (only for repos, defaults to `"main"`).
+        read_only (`bool` or `None`):
+            Read-only mount. Forced `True` for repos, defaults to `False` for buckets.
+        path (`str` or `None`):
+            Subfolder prefix inside the bucket/repo to mount, e.g. `"path/to/dir"`.
+    """
+
+    type: Literal["bucket", "model", "dataset", "space"]
+    source: str
+    mount_path: str
+    revision: str | None = None
+    read_only: bool | None = None
+    path: str | None = None
+
+    def __init__(self, **kwargs) -> None:
+        self.type = kwargs.get("type", "model")
+        self.source = kwargs["source"]
+        mount_path = kwargs.get("mountPath")
+        self.mount_path = mount_path if mount_path is not None else kwargs["mount_path"]
+        self.revision = kwargs.get("revision")
+        read_only = kwargs.get("readOnly")
+        self.read_only = read_only if read_only is not None else kwargs.get("read_only")
+        self.path = kwargs.get("path")
+
+    def to_dict(self) -> dict:
+        """Serialize to the JSON payload expected by the Hub API."""
+        data: dict = {
+            "type": self.type,
+            "source": self.source,
+            "mountPath": self.mount_path,
+        }
+        if self.revision is not None:
+            data["revision"] = self.revision
+        if self.read_only is not None:
+            data["readOnly"] = self.read_only
+        if self.path is not None:
+            data["path"] = self.path
+        return data
+
+    def to_uri(self) -> str:
+        """Return the volume as an HF mount URI in the format expected by the CLI."""
+        return HfMount(
+            source=HfUri(type=self.type, id=self.source, revision=self.revision, path_in_repo=self.path or ""),
+            mount_path=self.mount_path,
+            read_only=self.read_only,
+        ).to_uri()
+
+
+@dataclass
+class SpaceHotReloading:
+    status: Literal["created", "canceled"]
+    replica_statuses: list[tuple[str, str | None]]  # See _hot_reloading_types.ApiCreateReloadResponse.res.status
+    raw: dict
+
+    def __init__(self, data: dict) -> None:
+        self.status = data["status"]
+        self.replica_statuses = data["replicaStatuses"]
+        self.raw = data
+
+
+@dataclass
+class SpaceRuntime:
+    """
+    Contains information about the current runtime of a Space.
+
+    Args:
+        stage (`str`):
+            Current stage of the space. Example: RUNNING.
+        hardware (`str` or `None`):
+            Current hardware of the space. Example: "cpu-basic". Can be `None` if Space
+            is `BUILDING` for the first time.
+        requested_hardware (`str` or `None`):
+            Requested hardware. Can be different from `hardware` especially if the request
+            has just been made. Example: "t4-medium". Can be `None` if no hardware has
+            been requested yet.
+        sleep_time (`int` or `None`):
+            Number of seconds the Space will be kept alive after the last request. By default (if value is `None`), the
+            Space will never go to sleep if it's running on an upgraded hardware, while it will go to sleep after 48
+            hours on a free 'cpu-basic' hardware. For more details, see https://huggingface.co/docs/hub/spaces-gpus#sleep-time.
+        volumes (`list[Volume]` or `None`):
+            List of volumes mounted in the Space. Each volume is a [`Volume`] object describing its type, source,
+            mount path, and optional settings. `None` if no volumes are attached.
+        raw (`dict`):
+            Raw response from the server. Contains more information about the Space
+            runtime like number of replicas, number of cpu, memory size,...
+    """
+
+    stage: SpaceStage
+    hardware: SpaceHardware | None
+    requested_hardware: SpaceHardware | None
+    sleep_time: int | None
+    storage: SpaceStorage | None
+    dev_mode: bool
+    hot_reloading: SpaceHotReloading | None
+    volumes: list[Volume] | None
+    raw: dict
+
+    def __init__(self, data: dict) -> None:
+        self.stage = data["stage"]
+        self.hardware = data.get("hardware", {}).get("current")
+        self.requested_hardware = data.get("hardware", {}).get("requested")
+        self.sleep_time = data.get("gcTimeout")
+        self.storage = data.get("storage")
+        self.dev_mode = data.get("devMode", False)
+        self.hot_reloading = SpaceHotReloading(raw_hr) if (raw_hr := data.get("hotReloading")) is not None else None
+        raw_volumes = data.get("volumes")
+        self.volumes = [Volume(**v) for v in raw_volumes] if raw_volumes is not None else None
+        self.raw = data
+
+
+@dataclass
+class SpaceSecret:
+    """
+    Contains information about a secret of a Space.
+
+    Secret values are write-only and cannot be read back. Only the key, description,
+    and last update time are returned by the API.
+
+    Args:
+        key (`str`):
+            Secret key. Example: `"GITHUB_API_KEY"`
+        description (`str` or None):
+            Description of the secret. Example: `"Github API key to access the Github API"`.
+        updated_at (`datetime` or None):
+            datetime of the last update of the secret (if the secret has been updated at least once).
+    """
+
+    key: str
+    description: str | None
+    updated_at: datetime | None
+
+    def __init__(self, key: str, values: dict) -> None:
+        self.key = key
+        self.description = values.get("description")
+        updated_at = values.get("updatedAt")
+        self.updated_at = parse_datetime(updated_at) if updated_at is not None else None
+
+
+@dataclass
+class SpaceVariable:
+    """
+    Contains information about the current variables of a Space.
+
+    Args:
+        key (`str`):
+            Variable key. Example: `"MODEL_REPO_ID"`
+        value (`str`):
+            Variable value. Example: `"the_model_repo_id"`.
+        description (`str` or None):
+            Description of the variable. Example: `"Model Repo ID of the implemented model"`.
+        updatedAt (`datetime` or None):
+            datetime of the last update of the variable (if the variable has been updated at least once).
+    """
+
+    key: str
+    value: str
+    description: str | None
+    updated_at: datetime | None
+
+    def __init__(self, key: str, values: dict) -> None:
+        self.key = key
+        self.value = values["value"]
+        self.description = values.get("description")
+        updated_at = values.get("updatedAt")
+        self.updated_at = parse_datetime(updated_at) if updated_at is not None else None
+
+
+@dataclass
+class SpaceSearchResult:
+    """A single result from the Spaces semantic search API.
+
+    Returned by [`HfApi.search_spaces`].
+
+    Attributes:
+        id (`str`):
+            ID of the Space (e.g. `"username/repo-name"`).
+        author (`str`):
+            Author of the Space.
+        title (`str`):
+            Display title of the Space.
+        emoji (`str` or `None`):
+            Emoji icon of the Space.
+        sdk (`str` or `None`):
+            SDK used by the Space (e.g. `"gradio"`, `"docker"`, `"static"`).
+        likes (`int`):
+            Number of likes.
+        private (`bool`):
+            Whether the Space is private.
+        tags (`list[str]` or `None`):
+            List of tags.
+        runtime ([`SpaceRuntime`] or `None`):
+            Runtime information (stage, hardware, etc.).
+        ai_short_description (`str` or `None`):
+            AI-generated short description.
+        ai_category (`str` or `None`):
+            AI-generated category (e.g. `"Image Generation"`).
+        semantic_relevancy_score (`float` or `None`):
+            Semantic relevancy score (0-1) relative to the search query.
+        trending_score (`int` or `None`):
+            Trending score.
+    """
+
+    id: str
+    author: str
+    title: str
+    emoji: str | None
+    sdk: str | None
+    likes: int
+    private: bool
+    tags: list[str] | None
+    runtime: SpaceRuntime | None
+    ai_short_description: str | None
+    ai_category: str | None
+    semantic_relevancy_score: float | None
+    trending_score: int | None
+
+    def __init__(self, data: dict) -> None:
+        runtime = data.get("runtime")
+        self.id = data["id"]
+        self.author = data.get("author", "")
+        self.title = data.get("title", "")
+        self.emoji = data.get("emoji")
+        self.sdk = data.get("sdk")
+        self.likes = data.get("likes", 0)
+        self.private = data.get("private", False)
+        self.tags = data.get("tags")
+        self.runtime = SpaceRuntime(runtime) if runtime else None
+        self.ai_short_description = data.get("ai_short_description")
+        self.ai_category = data.get("ai_category")
+        self.semantic_relevancy_score = data.get("semanticRelevancyScore")
+        self.trending_score = data.get("trendingScore")
+
+
+@dataclass
+class SpaceTemplate:
+    """
+    Contains information about a Space template available on the Hub.
+
+    Returned by [`HfApi.list_space_templates`]. The `repo_id` can be passed as `space_template`
+    to [`HfApi.create_repo`] to seed a new Space from that template.
+
+    Args:
+        name (`str`):
+            Human-friendly name of the template (e.g. `"JupyterLab"`, `"chatbot"`).
+        repo_id (`str`):
+            Repo id of the template Space (e.g. `"SpacesExamples/jupyterlab"`).
+        sdk (`str`):
+            SDK the template is built with (e.g. `"gradio"`, `"docker"`, `"static"`).
+        preferred_private (`bool`):
+            Whether Spaces created from this template are recommended to be private.
+    """
+
+    name: str
+    repo_id: str
+    sdk: str
+    preferred_private: bool
+
+    def __init__(self, data: dict) -> None:
+        self.name = data["name"]
+        self.repo_id = data["repoId"]
+        self.sdk = data["sdk"]
+        self.preferred_private = data["preferredPrivate"]

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_tensorboard_logger.py

@@ -0,0 +1,189 @@
+# Copyright 2023 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 a logger to push training logs to the Hub, using Tensorboard."""
+
+from pathlib import Path
+
+from ._commit_scheduler import CommitScheduler
+from .errors import EntryNotFoundError
+from .repocard import ModelCard
+from .utils import experimental
+
+
+# Depending on user's setup, SummaryWriter can come either from 'tensorboardX'
+# or from 'torch.utils.tensorboard'. Both are compatible so let's try to load
+# from either of them.
+try:
+    from tensorboardX import SummaryWriter as _RuntimeSummaryWriter
+
+    is_summary_writer_available = True
+except ImportError:
+    try:
+        from torch.utils.tensorboard import SummaryWriter as _RuntimeSummaryWriter
+
+        is_summary_writer_available = True
+    except ImportError:
+        # Dummy class to avoid failing at import. Will raise on instance creation.
+        class _DummySummaryWriter:
+            pass
+
+        _RuntimeSummaryWriter = _DummySummaryWriter  # type: ignore[assignment]  # ty: ignore[conflicting-declarations]
+        is_summary_writer_available = False
+
+
+class HFSummaryWriter(_RuntimeSummaryWriter):
+    """
+    Wrapper around the tensorboard's `SummaryWriter` to push training logs to the Hub.
+
+    Data is logged locally and then pushed to the Hub asynchronously. Pushing data to the Hub is done in a separate
+    thread to avoid blocking the training script. In particular, if the upload fails for any reason (e.g. a connection
+    issue), the main script will not be interrupted. Data is automatically pushed to the Hub every `commit_every`
+    minutes (default to every 5 minutes).
+
+    > [!WARNING]
+    > `HFSummaryWriter` is experimental. Its API is subject to change in the future without prior notice.
+
+    Args:
+        repo_id (`str`):
+            The id of the repo to which the logs will be pushed.
+        logdir (`str`, *optional*):
+            The directory where the logs will be written. If not specified, a local directory will be created by the
+            underlying `SummaryWriter` object.
+        commit_every (`int` or `float`, *optional*):
+            The frequency (in minutes) at which the logs will be pushed to the Hub. Defaults to 5 minutes.
+        squash_history (`bool`, *optional*):
+            Whether to squash the history of the repo after each commit. Defaults to `False`. Squashing commits is
+            useful to avoid degraded performances on the repo when it grows too large.
+        repo_type (`str`, *optional*):
+            The type of the repo to which the logs will be pushed. Defaults to "model".
+        repo_revision (`str`, *optional*):
+            The revision of the repo to which the logs will be pushed. Defaults to "main".
+        repo_private (`bool`, *optional*):
+            Whether to make the repo private. If `None` (default), the repo will be public unless the organization's default is private. This value is ignored if the repo already exists.
+        path_in_repo (`str`, *optional*):
+            The path to the folder in the repo where the logs will be pushed. Defaults to "tensorboard/".
+        repo_allow_patterns (`list[str]` or `str`, *optional*):
+            A list of patterns to include in the upload. Defaults to `"*.tfevents.*"`. Check out the
+            [upload guide](https://huggingface.co/docs/huggingface_hub/guides/upload#upload-a-folder) for more details.
+        repo_ignore_patterns (`list[str]` or `str`, *optional*):
+            A list of patterns to exclude in the upload. Check out the
+            [upload guide](https://huggingface.co/docs/huggingface_hub/guides/upload#upload-a-folder) for more details.
+        token (`str`, *optional*):
+            Authentication token. Will default to the stored token. See https://huggingface.co/settings/token for more
+            details
+        kwargs:
+            Additional keyword arguments passed to `SummaryWriter`.
+
+    Examples:
+    ```diff
+    # Taken from https://pytorch.org/docs/stable/tensorboard.html
+    - from torch.utils.tensorboard import SummaryWriter
+    + from huggingface_hub import HFSummaryWriter
+
+    import numpy as np
+
+    - writer = SummaryWriter()
+    + writer = HFSummaryWriter(repo_id="username/my-trained-model")
+
+    for n_iter in range(100):
+        writer.add_scalar('Loss/train', np.random.random(), n_iter)
+        writer.add_scalar('Loss/test', np.random.random(), n_iter)
+        writer.add_scalar('Accuracy/train', np.random.random(), n_iter)
+        writer.add_scalar('Accuracy/test', np.random.random(), n_iter)
+    ```
+
+    ```py
+    >>> from huggingface_hub import HFSummaryWriter
+
+    # Logs are automatically pushed every 15 minutes (5 by default) + when exiting the context manager
+    >>> with HFSummaryWriter(repo_id="test_hf_logger", commit_every=15) as logger:
+    ...     logger.add_scalar("a", 1)
+    ...     logger.add_scalar("b", 2)
+    ```
+    """
+
+    @experimental
+    def __new__(cls, *args, **kwargs) -> "HFSummaryWriter":
+        if not is_summary_writer_available:
+            raise ImportError(
+                "You must have `tensorboard` installed to use `HFSummaryWriter`. Please run `pip install --upgrade"
+                " tensorboardX` first."
+            )
+        return super().__new__(cls)
+
+    def __init__(
+        self,
+        repo_id: str,
+        *,
+        logdir: str | None = None,
+        commit_every: int | float = 5,
+        squash_history: bool = False,
+        repo_type: str | None = None,
+        repo_revision: str | None = None,
+        repo_private: bool | None = None,
+        path_in_repo: str | None = "tensorboard",
+        repo_allow_patterns: list[str] | str | None = "*.tfevents.*",
+        repo_ignore_patterns: list[str] | str | None = None,
+        token: str | None = None,
+        **kwargs,
+    ):
+        # Initialize SummaryWriter
+        super().__init__(logdir=logdir, **kwargs)
+
+        # Check logdir has been correctly initialized and fail early otherwise. In practice, SummaryWriter takes care of it.
+        if not isinstance(self.logdir, str):
+            raise ValueError(f"`self.logdir` must be a string. Got '{self.logdir}' of type {type(self.logdir)}.")
+
+        # Append logdir name to `path_in_repo`
+        if path_in_repo is None or path_in_repo == "":
+            path_in_repo = Path(self.logdir).name
+        else:
+            path_in_repo = path_in_repo.strip("/") + "/" + Path(self.logdir).name
+
+        # Initialize scheduler
+        self.scheduler = CommitScheduler(
+            folder_path=self.logdir,
+            path_in_repo=path_in_repo,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=repo_revision,
+            private=repo_private,
+            token=token,
+            allow_patterns=repo_allow_patterns,
+            ignore_patterns=repo_ignore_patterns,
+            every=commit_every,
+            squash_history=squash_history,
+        )
+
+        # Exposing some high-level info at root level
+        self.repo_id = self.scheduler.repo_id
+        self.repo_type = self.scheduler.repo_type
+        self.repo_revision = self.scheduler.revision
+
+        # Add `hf-summary-writer` tag to the model card metadata
+        try:
+            card = ModelCard.load(repo_id_or_path=self.repo_id, repo_type=self.repo_type)
+        except EntryNotFoundError:
+            card = ModelCard("")
+        tags = card.data.get("tags", [])
+        if "hf-summary-writer" not in tags:
+            tags.append("hf-summary-writer")
+            card.data["tags"] = tags
+            card.push_to_hub(repo_id=self.repo_id, repo_type=self.repo_type)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Push to hub in a non-blocking way when exiting the logger's context manager."""
+        super().__exit__(exc_type, exc_val, exc_tb)
+        future = self.scheduler.trigger()
+        future.result()

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_tree_cache.py

@@ -0,0 +1,138 @@
+# 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.
+"""On-disk cache for repository tree listings.
+
+A tree listing is the set of files (with their download metadata) contained in a repo at a given commit. Because a
+commit hash is immutable, its tree listing never changes and can be cached forever without any invalidation logic.
+
+The listing is stored as a human-readable JSON file under `<tree_cache_folder>/trees/<commit_hash>.json`. The
+folder depends on the download target: the per-repo `storage_folder` for `cache_dir` downloads, or
+`local_dir/.cache/huggingface/` for `local_dir` downloads (see `tree_cache_folder_for_local_dir`).
+
+```json
+{
+  "format_version": 1,
+  "files": {
+    "config.json": {"size": 519, "blob_id": "<git sha1>"},
+    "model.safetensors": {"size": 1234, "blob_id": "...", "lfs_sha256": "<sha256>", "lfs_size": 1234, "xet_hash": "..."}
+  }
+}
+```
+"""
+
+import json
+import os
+import tempfile
+import threading
+from dataclasses import dataclass
+
+from .utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+TREE_CACHE_FORMAT_VERSION = 1
+
+# In-memory cache of parsed tree listings, keyed by absolute file path.
+_IN_MEMORY_TREE_CACHE: dict[str, "dict[str, TreeCacheEntry]"] = {}
+_IN_MEMORY_TREE_CACHE_LOCK = threading.Lock()
+
+
+@dataclass(frozen=True)
+class TreeCacheEntry:
+    """Raw metadata of a single file in a cached tree listing, mirroring the `/tree` endpoint fields."""
+
+    size: int
+    blob_id: str
+    lfs_sha256: str | None = None
+    lfs_size: int | None = None
+    xet_hash: str | None = None
+
+    def to_json(self) -> dict:
+        info: dict = {"size": self.size, "blob_id": self.blob_id}
+        if self.lfs_sha256 is not None:
+            info["lfs_sha256"] = self.lfs_sha256
+            info["lfs_size"] = self.lfs_size
+        if self.xet_hash is not None:
+            info["xet_hash"] = self.xet_hash
+        return info
+
+    @classmethod
+    def from_json(cls, info: dict) -> "TreeCacheEntry":
+        return cls(
+            size=info["size"],
+            blob_id=info["blob_id"],
+            lfs_sha256=info.get("lfs_sha256"),
+            lfs_size=info.get("lfs_size"),
+            xet_hash=info.get("xet_hash"),
+        )
+
+
+def _tree_cache_path(tree_cache_folder: str, commit_hash: str) -> str:
+    return os.path.join(tree_cache_folder, "trees", f"{commit_hash}.json")
+
+
+def tree_cache_folder_for_local_dir(local_dir: str) -> str:
+    """Folder under which the `trees/` cache lives for a `local_dir` download."""
+    return os.path.join(local_dir, ".cache", "huggingface")
+
+
+def read_tree_cache(tree_cache_folder: str, commit_hash: str) -> dict[str, TreeCacheEntry] | None:
+    """Return the cached tree listing for a commit hash, or `None` if not cached (or unreadable)."""
+    path = _tree_cache_path(tree_cache_folder, commit_hash)
+    with _IN_MEMORY_TREE_CACHE_LOCK:
+        if path in _IN_MEMORY_TREE_CACHE:
+            return _IN_MEMORY_TREE_CACHE[path]
+    entries = _read_tree_cache_from_disk(path)
+    if entries is not None:
+        with _IN_MEMORY_TREE_CACHE_LOCK:
+            _IN_MEMORY_TREE_CACHE[path] = entries
+    return entries
+
+
+def _read_tree_cache_from_disk(path: str) -> dict[str, TreeCacheEntry] | None:
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+        if data.get("format_version") != TREE_CACHE_FORMAT_VERSION:
+            # Unknown format (e.g. written by a newer version) => ignore and re-fetch.
+            return None
+        return {file_path: TreeCacheEntry.from_json(info) for file_path, info in data["files"].items()}
+    except FileNotFoundError:
+        return None
+    except (OSError, ValueError, KeyError, TypeError) as e:
+        logger.warning(f"Ignoring corrupted tree cache file {path}: {e}")
+        return None
+
+
+def write_tree_cache(tree_cache_folder: str, commit_hash: str, entries: dict[str, TreeCacheEntry]) -> None:
+    """Write the tree listing of a commit hash to the cache (ignoring any failures)."""
+    path = _tree_cache_path(tree_cache_folder, commit_hash)
+    data = {
+        "format_version": TREE_CACHE_FORMAT_VERSION,
+        "files": {file_path: entries[file_path].to_json() for file_path in sorted(entries)},
+    }
+    try:
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        tmp_fd, tmp_path = tempfile.mkstemp(dir=os.path.dirname(path), suffix=".tmp")
+        with os.fdopen(tmp_fd, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=1)
+        os.replace(tmp_path, path)
+    except OSError as e:
+        logger.warning(f"Ignored error while writing tree cache file {path}: {e}")
+        return
+
+    # Seed the in-memory cache so later readers of this commit skip re-reading and re-parsing the file.
+    with _IN_MEMORY_TREE_CACHE_LOCK:
+        _IN_MEMORY_TREE_CACHE[path] = dict(entries)

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_upload_large_folder.py

@@ -0,0 +1,769 @@
+# Copyright 2024-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.
+import enum
+import logging
+import os
+import queue
+import shutil
+import sys
+import threading
+import time
+import traceback
+from datetime import datetime
+from pathlib import Path
+from threading import Lock
+from typing import TYPE_CHECKING, Any
+from urllib.parse import quote
+
+from ._commit_api import CommitOperationAdd, UploadInfo, _fetch_upload_modes
+from ._local_folder import LocalUploadFileMetadata, LocalUploadFilePaths, get_local_upload_paths, read_upload_metadata
+from .constants import DEFAULT_REVISION, REPO_TYPES
+from .utils import DEFAULT_IGNORE_PATTERNS, _format_size, filter_repo_objects, tqdm
+from .utils._runtime import is_xet_available
+from .utils.sha import sha_fileobj
+
+
+if TYPE_CHECKING:
+    from .hf_api import HfApi
+
+logger = logging.getLogger(__name__)
+
+WAITING_TIME_IF_NO_TASKS = 10  # seconds
+MAX_NB_FILES_FETCH_UPLOAD_MODE = 100
+COMMIT_SIZE_SCALE: list[int] = [20, 50, 75, 100, 125, 200, 250, 400, 600, 1000]
+
+UPLOAD_BATCH_SIZE_XET = 256  # Max 256 files per upload batch for XET-enabled repos
+UPLOAD_BATCH_SIZE_LFS = 1  # Otherwise, batches of 1 for regular LFS upload
+
+# Repository limits (from https://huggingface.co/docs/hub/repositories-recommendations)
+MAX_FILES_PER_REPO = 100_000  # Recommended maximum number of files per repository
+MAX_FILES_PER_FOLDER = 10_000  # Recommended maximum number of files per folder
+MAX_FILE_SIZE_GB = 200  # Recommended maximum for individual file size (split larger files)
+RECOMMENDED_FILE_SIZE_GB = 20  # Recommended maximum for individual file size
+
+
+def _validate_upload_limits(paths_list: list[LocalUploadFilePaths]) -> None:
+    """
+    Validate upload against repository limits and warn about potential issues.
+
+    Args:
+        paths_list: List of file paths to be uploaded
+
+    Warns about:
+        - Too many files in the repository (>100k)
+        - Too many entries (files or subdirectories) in a single folder (>10k)
+        - Files exceeding size limits (>20GB recommended, >200GB maximum)
+    """
+    logger.info("Running validation checks on files to upload...")
+
+    # Check 1: Total file count
+    if len(paths_list) > MAX_FILES_PER_REPO:
+        logger.warning(
+            f"You are about to upload {len(paths_list):,} files. "
+            f"This exceeds the recommended limit of {MAX_FILES_PER_REPO:,} files per repository.\n"
+            f"Consider:\n"
+            f"  - Splitting your data into multiple repositories\n"
+            f"  - Using fewer, larger files (e.g., parquet files)\n"
+            f"  - See: https://huggingface.co/docs/hub/repositories-recommendations"
+        )
+
+    # Check 2: Files and subdirectories per folder
+    # Track immediate children (files and subdirs) for each folder
+    from collections import defaultdict
+
+    entries_per_folder: dict[str, Any] = defaultdict(lambda: {"files": 0, "subdirs": set()})
+
+    for paths in paths_list:
+        path = Path(paths.path_in_repo)
+        parts = path.parts
+
+        # Count this file in its immediate parent directory
+        parent = str(path.parent) if str(path.parent) != "." else "."
+        entries_per_folder[parent]["files"] += 1
+
+        # Track immediate subdirectories for each parent folder
+        # Walk through the path components to track parent-child relationships
+        for i, child in enumerate(parts[:-1]):
+            parent = "." if i == 0 else "/".join(parts[:i])
+            entries_per_folder[parent]["subdirs"].add(child)
+
+    # Check limits for each folder
+    for folder, data in entries_per_folder.items():
+        file_count = data["files"]
+        subdir_count = len(data["subdirs"])
+        total_entries = file_count + subdir_count
+
+        if total_entries > MAX_FILES_PER_FOLDER:
+            folder_display = "root" if folder == "." else folder
+            logger.warning(
+                f"Folder '{folder_display}' contains {total_entries:,} entries "
+                f"({file_count:,} files and {subdir_count:,} subdirectories). "
+                f"This exceeds the recommended {MAX_FILES_PER_FOLDER:,} entries per folder.\n"
+                "Consider reorganising into sub-folders."
+            )
+
+    # Check 3: File sizes
+    large_files = []
+    very_large_files = []
+
+    for paths in paths_list:
+        size = paths.file_path.stat().st_size
+        size_gb = size / 1_000_000_000  # Use decimal GB as per Hub limits
+
+        if size_gb > MAX_FILE_SIZE_GB:
+            very_large_files.append((paths.path_in_repo, size_gb))
+        elif size_gb > RECOMMENDED_FILE_SIZE_GB:
+            large_files.append((paths.path_in_repo, size_gb))
+
+    # Warn about very large files (>200GB)
+    if very_large_files:
+        files_str = "\n  - ".join(f"{path}: {size:.1f}GB" for path, size in very_large_files[:5])
+        more_str = f"\n  ... and {len(very_large_files) - 5} more files" if len(very_large_files) > 5 else ""
+        logger.warning(
+            f"Found {len(very_large_files)} files exceeding the {MAX_FILE_SIZE_GB}GB recommended maximum:\n"
+            f"  - {files_str}{more_str}\n"
+            f"Consider splitting these files into smaller chunks."
+        )
+
+    # Warn about large files (>20GB)
+    if large_files:
+        files_str = "\n  - ".join(f"{path}: {size:.1f}GB" for path, size in large_files[:5])
+        more_str = f"\n  ... and {len(large_files) - 5} more files" if len(large_files) > 5 else ""
+        logger.warning(
+            f"Found {len(large_files)} files larger than {RECOMMENDED_FILE_SIZE_GB}GB (recommended limit):\n"
+            f"  - {files_str}{more_str}\n"
+            f"Large files may slow down loading and processing."
+        )
+
+    logger.info("Validation checks complete.")
+
+
+def upload_large_folder_internal(
+    api: "HfApi",
+    repo_id: str,
+    folder_path: str | Path,
+    *,
+    repo_type: str,  # Repo type is required!
+    revision: str | None = None,
+    private: bool | None = None,
+    allow_patterns: list[str] | str | None = None,
+    ignore_patterns: list[str] | str | None = None,
+    num_workers: int | None = None,
+    print_report: bool = True,
+    print_report_every: int = 60,
+):
+    """Upload a large folder to the Hub in the most resilient way possible.
+
+    See [`HfApi.upload_large_folder`] for the full documentation.
+    """
+    # 1. Check args and setup
+    if repo_type is None:
+        raise ValueError(
+            "For large uploads, `repo_type` is explicitly required. Please set it to `model`, `dataset` or `space`."
+            " If you are using the CLI, pass it as `--repo-type=model`."
+        )
+    if repo_type not in REPO_TYPES:
+        raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
+    if revision is None:
+        revision = DEFAULT_REVISION
+
+    folder_path = Path(folder_path).expanduser().resolve()
+    if not folder_path.is_dir():
+        raise ValueError(f"Provided path: '{folder_path}' is not a directory")
+
+    if ignore_patterns is None:
+        ignore_patterns = []
+    elif isinstance(ignore_patterns, str):
+        ignore_patterns = [ignore_patterns]
+    ignore_patterns += DEFAULT_IGNORE_PATTERNS
+
+    if num_workers is None:
+        nb_cores = os.cpu_count() or 1
+        num_workers = max(nb_cores // 2, 1)  # Use at most half of cpu cores
+
+    # 2. Create repo if missing
+    repo_url = api.create_repo(repo_id=repo_id, repo_type=repo_type, private=private, exist_ok=True)
+    logger.info(f"Repo created: {repo_url}")
+    repo_id = repo_url.repo_id
+
+    # Warn on too many commits
+    try:
+        commits = api.list_repo_commits(repo_id=repo_id, repo_type=repo_type, revision=revision)
+        commit_count = len(commits)
+        if commit_count > 500:
+            logger.warning(
+                f"\n{'=' * 80}\n"
+                f"WARNING: This repository has {commit_count} commits.\n"
+                f"Repositories with a large number of commits can experience performance issues.\n"
+                f"\n"
+                f"Consider squashing your commit history using `super_squash_history()`.\n"
+                "To do so, you need to stop this process, run the snippet below and restart the upload command."
+                f"  from huggingface_hub import super_squash_history\n"
+                f"  super_squash_history(repo_id='{repo_id}', repo_type='{repo_type}')\n"
+                f"\n"
+                f"Note: This is a non-revertible operation. See the documentation for more details:\n"
+                f"https://huggingface.co/docs/huggingface_hub/main/en/package_reference/hf_api#huggingface_hub.HfApi.super_squash_history\n"
+                f"{'=' * 80}\n"
+            )
+    except Exception as e:
+        # Don't fail the upload if we can't check commit count
+        logger.debug(f"Could not check commit count: {e}")
+
+    # 2.1 Check if xet is enabled to set batch file upload size
+    upload_batch_size = UPLOAD_BATCH_SIZE_XET if is_xet_available() else UPLOAD_BATCH_SIZE_LFS
+
+    # 3. List files to upload
+    filtered_paths_list = filter_repo_objects(
+        (path.relative_to(folder_path).as_posix() for path in folder_path.glob("**/*") if path.is_file()),
+        allow_patterns=allow_patterns,
+        ignore_patterns=ignore_patterns,
+    )
+    paths_list = [get_local_upload_paths(folder_path, relpath) for relpath in filtered_paths_list]
+    logger.info(f"Found {len(paths_list)} candidate files to upload")
+
+    # Validate upload against repository limits
+    _validate_upload_limits(paths_list)
+
+    logger.info("Starting upload...")
+
+    # Read metadata for each file
+    items = [
+        (paths, read_upload_metadata(folder_path, paths.path_in_repo))
+        for paths in tqdm(paths_list, desc="Recovering from metadata files")
+    ]
+
+    # 4. Start workers
+    status = LargeUploadStatus(items, upload_batch_size)
+    threads = [
+        threading.Thread(
+            target=_worker_job,
+            kwargs={
+                "status": status,
+                "api": api,
+                "repo_id": repo_id,
+                "repo_type": repo_type,
+                "revision": revision,
+            },
+        )
+        for _ in range(num_workers)
+    ]
+
+    for thread in threads:
+        thread.start()
+
+    # 5. Print regular reports
+    if print_report:
+        print("\n\n" + status.current_report())
+    last_report_ts = time.time()
+    while True:
+        time.sleep(1)
+        if time.time() - last_report_ts >= print_report_every:
+            if print_report:
+                _print_overwrite(status.current_report())
+            last_report_ts = time.time()
+        if status.is_done():
+            logger.info("Is done: exiting main loop")
+            break
+
+    for thread in threads:
+        thread.join()
+
+    logger.info(status.current_report())
+    logger.info("Upload is complete!")
+
+
+####################
+# Logic to manage workers and synchronize tasks
+####################
+
+
+class WorkerJob(enum.Enum):
+    SHA256 = enum.auto()
+    GET_UPLOAD_MODE = enum.auto()
+    PREUPLOAD_LFS = enum.auto()
+    COMMIT = enum.auto()
+    WAIT = enum.auto()  # if no tasks are available but we don't want to exit
+
+
+JOB_ITEM_T = tuple[LocalUploadFilePaths, LocalUploadFileMetadata]
+
+
+class LargeUploadStatus:
+    """Contains information, queues and tasks for a large upload process."""
+
+    def __init__(self, items: list[JOB_ITEM_T], upload_batch_size: int = 1):
+        self.items = items
+        self.queue_sha256: "queue.Queue[JOB_ITEM_T]" = queue.Queue()
+        self.queue_get_upload_mode: "queue.Queue[JOB_ITEM_T]" = queue.Queue()
+        self.queue_preupload_lfs: "queue.Queue[JOB_ITEM_T]" = queue.Queue()
+        self.queue_commit: "queue.Queue[JOB_ITEM_T]" = queue.Queue()
+        self.lock = Lock()
+
+        self.nb_workers_sha256: int = 0
+        self.nb_workers_get_upload_mode: int = 0
+        self.nb_workers_preupload_lfs: int = 0
+        self.upload_batch_size: int = upload_batch_size
+        self.nb_workers_commit: int = 0
+        self.nb_workers_waiting: int = 0
+        self.last_commit_attempt: float | None = None
+
+        self._started_at = datetime.now()
+        self._chunk_idx: int = 1
+        self._chunk_lock: Lock = Lock()
+
+        # Setup queues
+        for item in self.items:
+            paths, metadata = item
+            if metadata.sha256 is None:
+                self.queue_sha256.put(item)
+            elif metadata.upload_mode is None:
+                self.queue_get_upload_mode.put(item)
+            elif metadata.upload_mode == "lfs" and not metadata.is_uploaded:
+                self.queue_preupload_lfs.put(item)
+            elif not metadata.is_committed:
+                self.queue_commit.put(item)
+            else:
+                logger.debug(f"Skipping file {paths.path_in_repo} (already uploaded and committed)")
+
+    def target_chunk(self) -> int:
+        with self._chunk_lock:
+            return COMMIT_SIZE_SCALE[self._chunk_idx]
+
+    def update_chunk(self, success: bool, nb_items: int, duration: float) -> None:
+        with self._chunk_lock:
+            if not success:
+                logger.warning(f"Failed to commit {nb_items} files at once. Will retry with less files in next batch.")
+                self._chunk_idx -= 1
+            elif nb_items >= COMMIT_SIZE_SCALE[self._chunk_idx] and duration < 40:
+                logger.info(f"Successfully committed {nb_items} at once. Increasing the limit for next batch.")
+                self._chunk_idx += 1
+
+            self._chunk_idx = max(0, min(self._chunk_idx, len(COMMIT_SIZE_SCALE) - 1))
+
+    def current_report(self) -> str:
+        """Generate a report of the current status of the large upload."""
+        nb_hashed = 0
+        size_hashed = 0
+        nb_preuploaded = 0
+        nb_lfs = 0
+        nb_lfs_unsure = 0
+        size_preuploaded = 0
+        nb_committed = 0
+        size_committed = 0
+        total_size = 0
+        ignored_files = 0
+        total_files = 0
+
+        with self.lock:
+            for _, metadata in self.items:
+                if metadata.should_ignore:
+                    ignored_files += 1
+                    continue
+                total_size += metadata.size
+                total_files += 1
+                if metadata.sha256 is not None:
+                    nb_hashed += 1
+                    size_hashed += metadata.size
+                if metadata.upload_mode == "lfs":
+                    nb_lfs += 1
+                if metadata.upload_mode is None:
+                    nb_lfs_unsure += 1
+                if metadata.is_uploaded:
+                    nb_preuploaded += 1
+                    size_preuploaded += metadata.size
+                if metadata.is_committed:
+                    nb_committed += 1
+                    size_committed += metadata.size
+            total_size_str = _format_size(total_size)
+
+            now = datetime.now()
+            now_str = now.strftime("%Y-%m-%d %H:%M:%S")
+            elapsed = now - self._started_at
+            elapsed_str = str(elapsed).split(".")[0]  # remove milliseconds
+
+            message = "\n" + "-" * 10
+            message += f" {now_str} ({elapsed_str}) "
+            message += "-" * 10 + "\n"
+
+            message += "Files:   "
+            message += f"hashed {nb_hashed}/{total_files} ({_format_size(size_hashed)}/{total_size_str}) | "
+            message += f"pre-uploaded: {nb_preuploaded}/{nb_lfs} ({_format_size(size_preuploaded)}/{total_size_str})"
+            if nb_lfs_unsure > 0:
+                message += f" (+{nb_lfs_unsure} unsure)"
+            message += f" | committed: {nb_committed}/{total_files} ({_format_size(size_committed)}/{total_size_str})"
+            message += f" | ignored: {ignored_files}\n"
+
+            message += "Workers: "
+            message += f"hashing: {self.nb_workers_sha256} | "
+            message += f"get upload mode: {self.nb_workers_get_upload_mode} | "
+            message += f"pre-uploading: {self.nb_workers_preupload_lfs} | "
+            message += f"committing: {self.nb_workers_commit} | "
+            message += f"waiting: {self.nb_workers_waiting}\n"
+            message += "-" * 51
+
+            return message
+
+    def is_done(self) -> bool:
+        with self.lock:
+            return all(metadata.is_committed or metadata.should_ignore for _, metadata in self.items)
+
+
+def _worker_job(
+    status: LargeUploadStatus,
+    api: "HfApi",
+    repo_id: str,
+    repo_type: str,
+    revision: str,
+):
+    """
+    Main process for a worker. The worker will perform tasks based on the priority list until all files are uploaded
+    and committed. If no tasks are available, the worker will wait for 10 seconds before checking again.
+
+    If a task fails for any reason, the item(s) are put back in the queue for another worker to pick up.
+
+    Read `upload_large_folder` docstring for more information on how tasks are prioritized.
+    """
+    while True:
+        next_job: tuple[WorkerJob, list[JOB_ITEM_T]] | None = None
+
+        # Determine next task
+        next_job = _determine_next_job(status)
+        if next_job is None:
+            return
+        job, items = next_job
+
+        # Perform task
+        match job:
+            case WorkerJob.SHA256:
+                item = items[0]  # single item
+                try:
+                    _compute_sha256(item)
+                    status.queue_get_upload_mode.put(item)
+                except KeyboardInterrupt:
+                    raise
+                except Exception as e:
+                    logger.error(f"Failed to compute sha256: {e}")
+                    traceback.format_exc()
+                    status.queue_sha256.put(item)
+
+                with status.lock:
+                    status.nb_workers_sha256 -= 1
+
+            case WorkerJob.GET_UPLOAD_MODE:
+                try:
+                    _get_upload_mode(items, api=api, repo_id=repo_id, repo_type=repo_type, revision=revision)
+                except KeyboardInterrupt:
+                    raise
+                except Exception as e:
+                    logger.error(f"Failed to get upload mode: {e}")
+                    traceback.format_exc()
+
+                # Items are either:
+                # - dropped (if should_ignore)
+                # - put in LFS queue (if LFS)
+                # - put in commit queue (if regular)
+                # - or put back (if error occurred).
+                for item in items:
+                    _, metadata = item
+                    if metadata.should_ignore:
+                        continue
+                    match metadata.upload_mode:
+                        case "lfs":
+                            status.queue_preupload_lfs.put(item)
+                        case "regular":
+                            status.queue_commit.put(item)
+                        case _:
+                            status.queue_get_upload_mode.put(item)
+
+                with status.lock:
+                    status.nb_workers_get_upload_mode -= 1
+
+            case WorkerJob.PREUPLOAD_LFS:
+                try:
+                    _preupload_lfs(items, api=api, repo_id=repo_id, repo_type=repo_type, revision=revision)
+                    for item in items:
+                        status.queue_commit.put(item)
+                except KeyboardInterrupt:
+                    raise
+                except Exception as e:
+                    logger.error(f"Failed to preupload LFS: {e}")
+                    traceback.format_exc()
+                    for item in items:
+                        status.queue_preupload_lfs.put(item)
+
+                with status.lock:
+                    status.nb_workers_preupload_lfs -= 1
+
+            case WorkerJob.COMMIT:
+                start_ts = time.time()
+                success = True
+                try:
+                    _commit(items, api=api, repo_id=repo_id, repo_type=repo_type, revision=revision)
+                except KeyboardInterrupt:
+                    raise
+                except Exception as e:
+                    logger.error(f"Failed to commit: {e}")
+                    traceback.format_exc()
+                    for item in items:
+                        status.queue_commit.put(item)
+                    success = False
+                duration = time.time() - start_ts
+                status.update_chunk(success, len(items), duration)
+                with status.lock:
+                    status.last_commit_attempt = time.time()
+                    status.nb_workers_commit -= 1
+
+            case WorkerJob.WAIT:
+                time.sleep(WAITING_TIME_IF_NO_TASKS)
+                with status.lock:
+                    status.nb_workers_waiting -= 1
+
+
+def _determine_next_job(status: LargeUploadStatus) -> tuple[WorkerJob, list[JOB_ITEM_T]] | None:
+    with status.lock:
+        # 1. Commit if more than 5 minutes since last commit attempt (and at least 1 file)
+        if (
+            status.nb_workers_commit == 0
+            and status.queue_commit.qsize() > 0
+            and status.last_commit_attempt is not None
+            and time.time() - status.last_commit_attempt > 5 * 60
+        ):
+            status.nb_workers_commit += 1
+            logger.debug("Job: commit (more than 5 minutes since last commit attempt)")
+            return (WorkerJob.COMMIT, _get_n(status.queue_commit, status.target_chunk()))
+
+        # 2. Commit if at least 100 files are ready to commit
+        elif status.nb_workers_commit == 0 and status.queue_commit.qsize() >= 150:
+            status.nb_workers_commit += 1
+            logger.debug("Job: commit (>100 files ready)")
+            return (WorkerJob.COMMIT, _get_n(status.queue_commit, status.target_chunk()))
+
+        # 3. Get upload mode if at least 100 files
+        elif status.queue_get_upload_mode.qsize() >= MAX_NB_FILES_FETCH_UPLOAD_MODE:
+            status.nb_workers_get_upload_mode += 1
+            logger.debug(f"Job: get upload mode (>{MAX_NB_FILES_FETCH_UPLOAD_MODE} files ready)")
+            return (WorkerJob.GET_UPLOAD_MODE, _get_n(status.queue_get_upload_mode, MAX_NB_FILES_FETCH_UPLOAD_MODE))
+
+        # 4. Preupload LFS file if at least `status.upload_batch_size` files and no worker is preuploading LFS
+        elif status.queue_preupload_lfs.qsize() >= status.upload_batch_size and status.nb_workers_preupload_lfs == 0:
+            status.nb_workers_preupload_lfs += 1
+            logger.debug("Job: preupload LFS (no other worker preuploading LFS)")
+            return (WorkerJob.PREUPLOAD_LFS, _get_n(status.queue_preupload_lfs, status.upload_batch_size))
+
+        # 5. Compute sha256 if at least 1 file and no worker is computing sha256
+        elif status.queue_sha256.qsize() > 0 and status.nb_workers_sha256 == 0:
+            status.nb_workers_sha256 += 1
+            logger.debug("Job: sha256 (no other worker computing sha256)")
+            return (WorkerJob.SHA256, _get_one(status.queue_sha256))
+
+        # 6. Get upload mode if at least 1 file and no worker is getting upload mode
+        elif status.queue_get_upload_mode.qsize() > 0 and status.nb_workers_get_upload_mode == 0:
+            status.nb_workers_get_upload_mode += 1
+            logger.debug("Job: get upload mode (no other worker getting upload mode)")
+            return (WorkerJob.GET_UPLOAD_MODE, _get_n(status.queue_get_upload_mode, MAX_NB_FILES_FETCH_UPLOAD_MODE))
+
+        # 7. Preupload LFS file if at least `status.upload_batch_size` files
+        elif status.queue_preupload_lfs.qsize() >= status.upload_batch_size:
+            status.nb_workers_preupload_lfs += 1
+            logger.debug("Job: preupload LFS")
+            return (WorkerJob.PREUPLOAD_LFS, _get_n(status.queue_preupload_lfs, status.upload_batch_size))
+
+        # 8. Compute sha256 if at least 1 file
+        elif status.queue_sha256.qsize() > 0:
+            status.nb_workers_sha256 += 1
+            logger.debug("Job: sha256")
+            return (WorkerJob.SHA256, _get_one(status.queue_sha256))
+
+        # 9. Get upload mode if at least 1 file
+        elif status.queue_get_upload_mode.qsize() > 0:
+            status.nb_workers_get_upload_mode += 1
+            logger.debug("Job: get upload mode")
+            return (WorkerJob.GET_UPLOAD_MODE, _get_n(status.queue_get_upload_mode, MAX_NB_FILES_FETCH_UPLOAD_MODE))
+
+        # 10. Preupload LFS file if at least 1 file
+        elif status.queue_preupload_lfs.qsize() > 0:
+            status.nb_workers_preupload_lfs += 1
+            logger.debug("Job: preupload LFS")
+            return (WorkerJob.PREUPLOAD_LFS, _get_n(status.queue_preupload_lfs, status.upload_batch_size))
+
+        # 11. Commit if at least 1 file and 1 min since last commit attempt
+        elif (
+            status.nb_workers_commit == 0
+            and status.queue_commit.qsize() > 0
+            and status.last_commit_attempt is not None
+            and time.time() - status.last_commit_attempt > 1 * 60
+        ):
+            status.nb_workers_commit += 1
+            logger.debug("Job: commit (1 min since last commit attempt)")
+            return (WorkerJob.COMMIT, _get_n(status.queue_commit, status.target_chunk()))
+
+        # 12. Commit if at least 1 file all other queues are empty and all workers are waiting
+        #     e.g. when it's the last commit
+        elif (
+            status.nb_workers_commit == 0
+            and status.queue_commit.qsize() > 0
+            and status.queue_sha256.qsize() == 0
+            and status.queue_get_upload_mode.qsize() == 0
+            and status.queue_preupload_lfs.qsize() == 0
+            and status.nb_workers_sha256 == 0
+            and status.nb_workers_get_upload_mode == 0
+            and status.nb_workers_preupload_lfs == 0
+        ):
+            status.nb_workers_commit += 1
+            logger.debug("Job: commit")
+            return (WorkerJob.COMMIT, _get_n(status.queue_commit, status.target_chunk()))
+
+        # 13. If all queues are empty, exit
+        elif all(metadata.is_committed or metadata.should_ignore for _, metadata in status.items):
+            logger.info("All files have been processed! Exiting worker.")
+            return None
+
+        # 14. If no task is available, wait
+        else:
+            status.nb_workers_waiting += 1
+            logger.debug(f"No task available, waiting... ({WAITING_TIME_IF_NO_TASKS}s)")
+            return (WorkerJob.WAIT, [])
+
+
+####################
+# Atomic jobs (sha256, get_upload_mode, preupload_lfs, commit)
+####################
+
+
+def _compute_sha256(item: JOB_ITEM_T) -> None:
+    """Compute sha256 of a file and save it in metadata."""
+    paths, metadata = item
+    if metadata.sha256 is None:
+        with paths.file_path.open("rb") as f:
+            metadata.sha256 = sha_fileobj(f).hex()
+    metadata.save(paths)
+
+
+def _get_upload_mode(items: list[JOB_ITEM_T], api: "HfApi", repo_id: str, repo_type: str, revision: str) -> None:
+    """Get upload mode for each file and update metadata.
+
+    Also receive info if the file should be ignored.
+    """
+    additions = [_build_hacky_operation(item) for item in items]
+    _fetch_upload_modes(
+        additions=additions,
+        repo_type=repo_type,
+        repo_id=repo_id,
+        headers=api._build_hf_headers(),
+        revision=quote(revision, safe=""),
+        endpoint=api.endpoint,
+    )
+    for item, addition in zip(items, additions):
+        paths, metadata = item
+        metadata.upload_mode = addition._upload_mode
+        metadata.should_ignore = addition._should_ignore
+        metadata.remote_oid = addition._remote_oid
+        metadata.save(paths)
+
+
+def _preupload_lfs(items: list[JOB_ITEM_T], api: "HfApi", repo_id: str, repo_type: str, revision: str) -> None:
+    """Preupload LFS files and update metadata."""
+    additions = [_build_hacky_operation(item) for item in items]
+    api.preupload_lfs_files(
+        repo_id=repo_id,
+        repo_type=repo_type,
+        revision=revision,
+        additions=additions,
+    )
+
+    for paths, metadata in items:
+        metadata.is_uploaded = True
+        metadata.save(paths)
+
+
+def _commit(items: list[JOB_ITEM_T], api: "HfApi", repo_id: str, repo_type: str, revision: str) -> None:
+    """Commit files to the repo."""
+    additions = [_build_hacky_operation(item) for item in items]
+    api.create_commit(
+        repo_id=repo_id,
+        repo_type=repo_type,
+        revision=revision,
+        operations=additions,
+        commit_message="Add files using upload-large-folder tool",
+    )
+    for paths, metadata in items:
+        metadata.is_committed = True
+        metadata.save(paths)
+
+
+####################
+# Hacks with CommitOperationAdd to bypass checks/sha256 calculation
+####################
+
+
+class HackyCommitOperationAdd(CommitOperationAdd):
+    def __post_init__(self) -> None:
+        if isinstance(self.path_or_fileobj, Path):
+            self.path_or_fileobj = str(self.path_or_fileobj)
+
+
+def _build_hacky_operation(item: JOB_ITEM_T) -> HackyCommitOperationAdd:
+    paths, metadata = item
+    operation = HackyCommitOperationAdd(path_in_repo=paths.path_in_repo, path_or_fileobj=paths.file_path)
+    with paths.file_path.open("rb") as file:
+        sample = file.peek(512)[:512]
+    if metadata.sha256 is None:
+        raise ValueError("sha256 must have been computed by now!")
+    operation.upload_info = UploadInfo(sha256=bytes.fromhex(metadata.sha256), size=metadata.size, sample=sample)
+    operation._upload_mode = metadata.upload_mode  # type: ignore
+    operation._should_ignore = metadata.should_ignore
+    operation._remote_oid = metadata.remote_oid
+    operation._is_uploaded = metadata.is_uploaded
+    if metadata.is_uploaded and metadata.upload_mode == "lfs":
+        operation.path_or_fileobj = b""
+    return operation
+
+
+####################
+# Misc helpers
+####################
+
+
+def _get_one(queue: "queue.Queue[JOB_ITEM_T]") -> list[JOB_ITEM_T]:
+    return [queue.get()]
+
+
+def _get_n(queue: "queue.Queue[JOB_ITEM_T]", n: int) -> list[JOB_ITEM_T]:
+    return [queue.get() for _ in range(min(queue.qsize(), n))]
+
+
+def _print_overwrite(report: str) -> None:
+    """Print a report, overwriting the previous lines.
+
+    Since tqdm in using `sys.stderr` to (re-)write progress bars, we need to use `sys.stdout`
+    to print the report.
+
+    Note: works well only if no other process is writing to `sys.stdout`!
+    """
+    report += "\n"
+    # Get terminal width
+    terminal_width = shutil.get_terminal_size().columns
+
+    # Count number of lines that should be cleared
+    nb_lines = sum(len(line) // terminal_width + 1 for line in report.splitlines())
+
+    # Clear previous lines based on the number of lines in the report
+    for _ in range(nb_lines):
+        sys.stdout.write("\r\033[K")  # Clear line
+        sys.stdout.write("\033[F")  # Move cursor up one line
+
+    # Print the new report, filling remaining space with whitespace
+    sys.stdout.write(report)
+    sys.stdout.write(" " * (terminal_width - len(report.splitlines()[-1])))
+    sys.stdout.flush()

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_upload_pipeline.py

@@ -0,0 +1,682 @@
+# coding=utf-8
+# 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.
+"""Streamed, multi-commit upload of a folder on top of the Xet upload protocol.
+
+How it works:
+
+- The **coordinator** (caller's thread) walks the list of files and asks the Hub, 256 files at a
+  time, what each file is (regular git blob, xet file, ignored). Regular files are accumulated
+  directly; xet files are registered into a `XetSession` upload-commit, which chunks, deduplicates,
+  retries and uploads them in the background while the coordinator keeps going. No Python-side
+  sha256 computation: `hf_xet` computes it during chunking (single read pass over each file).
+- Whenever enough files have accumulated (adaptive batch size), the batch is handed over to the
+  **committer** thread which joins the xet uploads, drops unchanged files, and creates a git
+  commit for the batch. While a batch is being committed, the coordinator is already uploading
+  the next one.
+- Interrupted uploads are resumable by simply re-running the same call: already-committed files
+  are dropped (no-op detection against the remote oid) and already-uploaded chunks are
+  deduplicated by the xet storage backend, transferring ~0 bytes.
+"""
+
+import queue
+import shutil
+import sys
+import threading
+import time
+from typing import TYPE_CHECKING, Any, Callable
+from urllib.parse import quote
+
+from . import constants
+from ._commit_api import (
+    CommitOperationAdd,
+    CommitOperationDelete,
+    _fetch_upload_modes,
+    _send_commit,
+    _warn_on_overwriting_operations,
+)
+from .errors import RepositoryNotFoundError
+from .utils import are_progress_bars_disabled, logging
+from .utils._xet import (
+    XetTokenType,
+    abort_xet_session,
+    get_xet_session,
+    xet_connection_info_refresh_url,
+    xet_headers_without_auth,
+)
+
+
+if TYPE_CHECKING:
+    from .hf_api import CommitInfo, HfApi
+
+logger = logging.get_logger(__name__)
+
+# Number of files sent to the "preupload" endpoint per call (server-side limit).
+PREUPLOAD_BATCH_SIZE = 256
+
+# Files per git commit: adaptive, scaled up after fast commits and down after failures.
+COMMIT_SIZE_SCALE = [20, 50, 75, 100, 125, 200, 250, 400, 600, 1000]
+INITIAL_COMMIT_SIZE_INDEX = 6  # start at 256 files per commit
+TARGET_COMMIT_DURATION = 40.0  # seconds; scale up batch size if commits are faster than this
+MAX_COMMIT_INTERVAL = 5 * 60.0  # seconds; force a commit if the current batch is older than this
+
+# Budget of regular-file content per commit (regular files are base64-encoded in the payload).
+REGULAR_CONTENT_BYTES_BUDGET = 100 * 1024 * 1024
+
+_SENTINEL = object()  # Sentinel value for the batch queue to indicate the end of the upload
+
+# Live display tuning
+_BAR_WIDTH = 20
+_REFRESH_INTERVAL = 0.5  # seconds between redraws on a TTY
+_NON_TTY_LOG_INTERVAL = 30.0  # seconds between summary logs when stderr is not a TTY
+
+
+def _bar(current: float, total: float, width: int = _BAR_WIDTH) -> str:
+    if total <= 0:
+        return "░" * width
+    filled = int(min(current / total, 1.0) * width)
+    return "█" * filled + "░" * (width - filled)
+
+
+def _format_bytes(n: float) -> str:
+    for unit in ("B", "kB", "MB", "GB", "TB"):
+        if abs(n) < 1000:
+            if n < 10:
+                return f"{n:.2f}{unit}"
+            elif n < 100:
+                return f"{n:.1f}{unit}"
+            return f"{n:.0f}{unit}"
+        n /= 1000
+    return f"{n:.1f}PB"
+
+
+class _LiveDisplay:
+    """Three-line live progress display on stderr::
+
+        Preparing   ████████████████████  11,100 / 11,100 ✓
+        Uploading   ██████████████░░░░░░  580 / 603 files  3.8GB · 19.7MB/s
+        Committing  ██████████████████░░  10,800 / 11,100  14 commits
+
+    A small renderer thread redraws the three lines in-place every ~0.5 s on a TTY
+    (worker threads only update counters under a lock). When stderr is not a TTY,
+    it falls back to a periodic ``logger.info`` summary instead.
+
+    Disabling progress bars (e.g. agent output mode) only turns off the TTY renderer:
+    the non-TTY log summaries are gated by the logger verbosity alone, so consumers
+    tailing stderr during a long upload still see periodic progress.
+    """
+
+    _N_LINES = 3
+
+    def __init__(self, total_files: int, enabled: bool = True) -> None:
+        self._total = total_files
+        self._tty = enabled and sys.stderr.isatty()
+        self._active = self._tty or logger.isEnabledFor(logging.INFO)
+        self._lock = threading.Lock()
+        self._drawn = False
+        self._stop_event = threading.Event()
+        self._thread: threading.Thread | None = None
+
+        # Counters (written by coordinator/committer threads, read by the renderer)
+        self._prepared = 0
+        self._ignored = 0
+        self._xet_total = 0
+        self._xet_done: set[str] = set()  # item names; unique across batches
+        self._committed = 0  # committed or skipped-as-unchanged
+        self._nb_commits = 0
+
+        # Xet transfer bytes, summed across (possibly concurrent) upload-commits
+        self._xet_bytes = 0
+        self._speed_ema = 0.0
+        self._prev_bytes = 0
+        self._prev_time: float | None = None
+
+    # -- lifecycle (main thread) ------------------------------------------------
+
+    def start(self) -> None:
+        if not self._active:
+            return
+        if self._tty:
+            sys.stderr.write(f"Found {self._total:,} files to upload\n")
+            sys.stderr.flush()
+        else:
+            logger.info(f"Found {self._total:,} files to upload")
+        self._thread = threading.Thread(target=self._render_loop, name="hf-upload-display", daemon=True)
+        self._thread.start()
+
+    def close(self) -> None:
+        if self._thread is not None:
+            self._stop_event.set()
+            self._thread.join()
+        if self._tty:
+            with self._lock:
+                self._redraw()  # final state
+
+    # -- counter updates (coordinator / committer / xet callback threads) --------
+
+    def notify_prepared(self, n: int) -> None:
+        with self._lock:
+            self._prepared += n
+
+    def notify_ignored(self, n: int) -> None:
+        with self._lock:
+            self._ignored += n
+
+    def notify_xet_registered(self, n: int) -> None:
+        with self._lock:
+            self._xet_total += n
+
+    def notify_xet_uploaded(self, names: list[str]) -> None:
+        with self._lock:
+            self._xet_done.update(names)
+
+    def notify_skipped(self, n: int) -> None:
+        with self._lock:
+            self._committed += n
+
+    def notify_commit(self, n_files: int) -> None:
+        with self._lock:
+            self._committed += n_files
+            self._nb_commits += 1
+
+    def new_xet_callback(self) -> "Callable | None":
+        """Progress callback for one ``new_upload_commit``.
+
+        The byte counters in ``group_report`` are cumulative *per upload-commit* and several
+        upload-commits can be in flight at once (one finalizing, one filling), so each commit
+        gets its own closure tracking its own previous value; increments are summed globally.
+        """
+        if not self._active:
+            return None
+        prev = 0
+
+        def callback(group_report: Any, item_reports: Any) -> None:
+            nonlocal prev
+            with self._lock:
+                completed = group_report.total_transfer_bytes_completed
+                self._xet_bytes += max(0, completed - prev)
+                prev = completed
+                for item in item_reports.values():
+                    if item.total_bytes > 0 and item.bytes_completed == item.total_bytes:
+                        self._xet_done.add(item.item_name)
+
+        return callback
+
+    # -- rendering (display thread) ----------------------------------------------
+
+    def _render_loop(self) -> None:
+        last_log = 0.0
+        while not self._stop_event.wait(_REFRESH_INTERVAL):
+            with self._lock:
+                self._update_speed()
+                if self._tty:
+                    self._redraw()
+                elif time.monotonic() - last_log >= _NON_TTY_LOG_INTERVAL:
+                    logger.info(self._summary())
+                    last_log = time.monotonic()
+
+    def _update_speed(self) -> None:
+        now = time.monotonic()
+        if self._prev_time is not None and now > self._prev_time:
+            rate = (self._xet_bytes - self._prev_bytes) / (now - self._prev_time)
+            self._speed_ema = rate if self._speed_ema == 0 else 0.3 * rate + 0.7 * self._speed_ema
+        self._prev_time = now
+        self._prev_bytes = self._xet_bytes
+
+    def _redraw(self) -> None:
+        if self._drawn:
+            sys.stderr.write(f"\033[{self._N_LINES}A")
+        width = shutil.get_terminal_size().columns
+        for line in (self._line_preparing(), self._line_uploading(), self._line_committing()):
+            truncated = line[: width - 4] + "..." if len(line) > width - 1 else line
+            sys.stderr.write(f"\r\033[K{truncated}\n")
+        sys.stderr.flush()
+        self._drawn = True
+
+    def _line_preparing(self) -> str:
+        done = " ✓" if self._prepared >= self._total else ""
+        return f"  Preparing   {_bar(self._prepared, self._total)}  {self._prepared:,} / {self._total:,}{done}"
+
+    def _line_uploading(self) -> str:
+        if self._xet_total == 0:
+            bar = _bar(1, 1) if self._prepared >= self._total else _bar(0, 1)
+            return f"  Uploading   {bar}  -"
+        n_done = len(self._xet_done)
+        parts = []
+        if self._xet_bytes > 0:
+            parts.append(_format_bytes(self._xet_bytes))
+        if self._speed_ema > 0:
+            parts.append(f"{_format_bytes(self._speed_ema)}/s")
+        extra = f"  {' · '.join(parts)}" if parts else ""
+        done = " ✓" if self._prepared >= self._total and n_done >= self._xet_total else ""
+        return f"  Uploading   {_bar(n_done, self._xet_total)}  {n_done:,} / {self._xet_total:,} files{extra}{done}"
+
+    def _line_committing(self) -> str:
+        effective = self._total - self._ignored
+        commits_str = f"  {self._nb_commits} commits" if self._nb_commits > 1 else ""
+        done = " ✓" if self._committed >= effective > 0 else ""
+        return (
+            f"  Committing  {_bar(self._committed, effective)}  {self._committed:,} / {effective:,}{commits_str}{done}"
+        )
+
+    def _summary(self) -> str:
+        return (
+            f"Uploading... {self._prepared:,}/{self._total:,} files checked, "
+            f"{len(self._xet_done):,}/{self._xet_total:,} uploaded ({_format_bytes(self._xet_bytes)} transferred), "
+            f"{self._committed:,} committed in {self._nb_commits} commit(s)"
+        )
+
+
+class _CommitPacer:
+    """Adaptive number of files per commit, to stay below server-side commit timeouts."""
+
+    def __init__(self) -> None:
+        self._index = INITIAL_COMMIT_SIZE_INDEX
+
+    @property
+    def target(self) -> int:
+        return COMMIT_SIZE_SCALE[self._index]
+
+    def record_success(self, duration: float, nb_files: int) -> None:
+        if duration < TARGET_COMMIT_DURATION and nb_files >= self.target:
+            self._index = min(self._index + 1, len(COMMIT_SIZE_SCALE) - 1)
+        elif duration > TARGET_COMMIT_DURATION:
+            self._index = max(self._index - 1, 0)
+
+    def record_failure(self) -> None:
+        self._index = max(self._index - 1, 0)
+
+
+class _Batch:
+    """A group of files destined to a single git commit, with their in-flight xet uploads."""
+
+    def __init__(self) -> None:
+        self.ops: list[CommitOperationAdd] = []
+        self.regular_bytes: int = 0
+        self.xet_commit: Any = None  # XetUploadCommit, opened lazily
+        self.handles: list[tuple[CommitOperationAdd, Any]] = []  # (op, XetFileUpload)
+        self.created_at: float = time.monotonic()
+
+
+class _UploadPipeline:
+    def __init__(
+        self,
+        api: "HfApi",
+        *,
+        repo_id: str,
+        repo_type: str,
+        add_operations: list[CommitOperationAdd],
+        delete_operations: list[CommitOperationDelete],
+        commit_message: str,
+        commit_description: str | None,
+        token: str | bool | None,
+        revision: str | None,
+        create_pr: bool,
+        parent_commit: str | None,
+    ) -> None:
+        self.api = api
+        self.repo_id = repo_id
+        self.repo_type = repo_type
+        self.add_operations = add_operations
+        self.delete_operations = delete_operations
+        self.commit_message = commit_message
+        self.commit_description = commit_description
+        self.token = token
+        self.headers = api._build_hf_headers(token=token)
+        self.revision = revision or constants.DEFAULT_REVISION
+        self.create_pr = create_pr
+        self.parent_commit = parent_commit
+
+        # The base revision is used by the coordinator for ALL preupload calls and the xet token
+        # refresh URL, with the `create_pr` flag — exactly like `create_commit` does. It never
+        # changes during the run, even after a PR has been created.
+        self.base_revision_quoted = quote(self.revision, safe="")
+
+        # Committer state (mutated by the committer thread only)
+        self.commit_revision_quoted = self.base_revision_quoted  # switched to the PR ref once created
+        self.pr_url: str | None = None
+        self.pr_revision: str | None = None
+        self.nb_commits = 0
+        self.last_commit_info: "CommitInfo | None" = None
+        self.pacer = _CommitPacer()
+
+        # Pipeline plumbing
+        self.batch_queue: queue.Queue = queue.Queue(maxsize=1)
+        self.errors: list[BaseException] = []
+        self.abort_event = threading.Event()
+        self.display = _LiveDisplay(total_files=len(add_operations), enabled=not are_progress_bars_disabled())
+
+        # All xet uploads share the same token refresh URL. With `create_pr`, the final ref is not
+        # known in advance: `?create_pr=1` makes the server grant a token valid for PR refs.
+        refresh_url = xet_connection_info_refresh_url(
+            token_type=XetTokenType.WRITE,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=self.base_revision_quoted,
+            endpoint=api.endpoint,
+        )
+        if create_pr:
+            refresh_url += "?create_pr=1"
+        self.xet_session = get_xet_session()
+        self.xet_commit_kwargs = {
+            "token_refresh_url": refresh_url,
+            "token_refresh_headers": self.headers,
+            "custom_headers": xet_headers_without_auth(self.headers),
+        }
+
+        # `.gitignore` rules are enforced server-side: forward the local one if it's being uploaded.
+        self.gitignore_content: str | None = None
+        for op in add_operations:
+            if op.path_in_repo == ".gitignore":
+                with op.as_file() as f:
+                    self.gitignore_content = f.read().decode()
+                break
+
+    def run(self) -> "CommitInfo":
+        _warn_on_overwriting_operations([*self.delete_operations, *self.add_operations])
+        committer = threading.Thread(target=self._committer_loop, name="hf-upload-committer", daemon=True)
+        committer.start()
+        self.display.start()
+        try:
+            self._coordinator_loop()
+        except BaseException:
+            self.abort_event.set()
+            abort_xet_session()
+            raise
+        finally:
+            if self.abort_event.is_set():
+                # The committer exits on its own once the queue is drained (see `_committer_loop`).
+                # Bound the wait so a xet call blocked on the (aborted) session can never hang the
+                # shutdown — the committer is a daemon thread.
+                committer.join(timeout=10)
+            else:
+                self.batch_queue.put(_SENTINEL)
+                committer.join()
+            self.display.close()
+            if self.abort_event.is_set() and self.pr_revision is not None:
+                logger.warning(
+                    f"Upload to pull request {self.pr_url} did not complete. To resume into the"
+                    f' same PR, re-run with `revision="{self.pr_revision}"` (without `create_pr=True`). Re-running'
+                    " with `create_pr=True` would open a new pull request."
+                )
+        if self.errors:
+            raise self.errors[0]
+        return self._final_commit_info()
+
+    # ---------------------------------------------------------------- coordinator
+
+    def _coordinator_loop(self) -> None:
+        import hf_xet
+
+        batch = _Batch()
+        for start in range(0, len(self.add_operations), PREUPLOAD_BATCH_SIZE):
+            if self.abort_event.is_set():
+                self._abort_batch(batch)
+                return
+            chunk = self.add_operations[start : start + PREUPLOAD_BATCH_SIZE]
+            try:
+                _fetch_upload_modes(
+                    additions=chunk,
+                    repo_type=self.repo_type,
+                    repo_id=self.repo_id,
+                    headers=self.headers,
+                    revision=self.base_revision_quoted,
+                    endpoint=self.api.endpoint,
+                    create_pr=self.create_pr,
+                    gitignore_content=self.gitignore_content,
+                )
+            except RepositoryNotFoundError as e:
+                from .hf_api import _CREATE_COMMIT_NO_REPO_ERROR_MESSAGE
+
+                e.append_to_message(_CREATE_COMMIT_NO_REPO_ERROR_MESSAGE)
+                raise
+            self.display.notify_prepared(len(chunk))
+            for op in chunk:
+                if op._should_ignore:
+                    logger.debug(f"Skipping upload for '{op.path_in_repo}' (ignored by gitignore rules).")
+                    self.display.notify_ignored(1)
+                    continue
+                if op._upload_mode == "regular":
+                    batch.regular_bytes += op.upload_info.size
+                else:
+                    if batch.xet_commit is None:
+                        batch.xet_commit = self.xet_session.new_upload_commit(
+                            progress_callback=self.display.new_xet_callback(), **self.xet_commit_kwargs
+                        )
+                    # Upload starts immediately in the background. sha256 is computed by hf_xet
+                    # while chunking, unless already known (e.g. resumed operations).
+                    sha_arg = op.upload_info.sha256.hex() if op.upload_info.is_hashed else hf_xet.COMPUTE_SHA256
+                    if isinstance(op.path_or_fileobj, bytes):
+                        handle = batch.xet_commit.start_upload_bytes(
+                            op.path_or_fileobj, sha256=sha_arg, name=op.path_in_repo
+                        )
+                    else:
+                        handle = batch.xet_commit.start_upload_file(str(op.path_or_fileobj), sha256=sha_arg)
+                    batch.handles.append((op, handle))
+                    self.display.notify_xet_registered(1)
+                batch.ops.append(op)
+
+                if (
+                    len(batch.ops) >= self.pacer.target
+                    or batch.regular_bytes >= REGULAR_CONTENT_BYTES_BUDGET
+                    or (time.monotonic() - batch.created_at > MAX_COMMIT_INTERVAL and len(batch.ops) > 0)
+                ):
+                    self._enqueue(batch)
+                    batch = _Batch()
+        self._enqueue(batch)
+
+    def _enqueue(self, batch: _Batch) -> None:
+        if len(batch.ops) == 0 and not (self.nb_commits == 0 and len(self.delete_operations) > 0):
+            return
+        # Blocks if a batch is already waiting: natural backpressure on scanning/uploading.
+        while not self.abort_event.is_set():
+            try:
+                self.batch_queue.put(batch, timeout=1.0)
+                return
+            except queue.Full:
+                continue
+        self._abort_batch(batch)
+
+    def _abort_batch(self, batch: _Batch) -> None:
+        if batch.xet_commit is not None:
+            try:
+                batch.xet_commit.abort()
+            except Exception:
+                pass
+
+    # ---------------------------------------------------------------- committer
+
+    def _committer_loop(self) -> None:
+        while True:
+            try:
+                batch = self.batch_queue.get(timeout=0.5)
+            except queue.Empty:
+                if self.abort_event.is_set():
+                    return  # aborted: exit once the queue is drained, no sentinel needed
+                continue
+            if batch is _SENTINEL:
+                return
+            try:
+                if not self.abort_event.is_set():
+                    self._process_batch(batch)
+                else:
+                    self._abort_batch(batch)
+            except BaseException as e:
+                self._abort_batch(batch)
+                self.errors.append(e)
+                self.abort_event.set()
+
+    def _process_batch(self, batch: _Batch) -> None:
+        # 1. Wait for all xet uploads of this batch and finalize them (atomic xet commit). Files
+        #    can only be referenced by a git commit once their xet upload-commit is finalized.
+        if batch.xet_commit is not None:
+            batch.xet_commit.wait_to_finish()
+            for op, handle in batch.handles:
+                if not op.upload_info.is_hashed:
+                    op.upload_info.sha256 = bytes.fromhex(handle.result().xet_info.sha256)
+                op._is_uploaded = True
+            # Files whose last progress tick was missed are still done at this point.
+            self.display.notify_xet_uploaded(
+                [
+                    str(op.path_or_fileobj) if not isinstance(op.path_or_fileobj, bytes) else op.path_in_repo
+                    for op, _ in batch.handles
+                ]
+            )
+
+        # 2. Drop files that have not changed compared to the remote (prevents empty commits).
+        #    Their chunks were deduplicated anyway (~0 bytes transferred).
+        ops_to_commit = []
+        for op in batch.ops:
+            if op._remote_oid is not None and op._remote_oid == op._local_oid:
+                logger.debug(f"Skipping commit for '{op.path_in_repo}' (file unchanged).")
+                self.display.notify_skipped(1)
+                continue
+            ops_to_commit.append(op)
+
+        # 3. Create the git commit(s). On failure, scale down and split the batch.
+        if len(ops_to_commit) > 0 or (self.nb_commits == 0 and len(self.delete_operations) > 0):
+            self._commit_with_split(ops_to_commit)
+
+    def _commit_with_split(self, ops: list[CommitOperationAdd]) -> None:
+        try:
+            self._do_commit(ops)
+        except Exception as e:
+            self.pacer.record_failure()
+            if len(ops) <= COMMIT_SIZE_SCALE[0]:
+                raise
+            logger.warning(f"Commit of {len(ops)} files failed ({e!r}). Retrying in smaller chunks.")
+            target = self.pacer.target
+            for start in range(0, len(ops), target):
+                self._commit_with_split(ops[start : start + target])
+
+    def _do_commit(self, ops: list[CommitOperationAdd]) -> None:
+        if self.create_pr and self.pr_revision is None:
+            # Create the (draft) pull request explicitly and push every commit to its ref. Committing
+            # with `?create_pr=1` instead would risk opening a second PR if the commit POST is retried
+            # after a lost response. Created lazily so that a fully-unchanged upload opens no PR.
+            # Note: PRs created this way are always opened against the default branch, hence the
+            # `create_pr` + `revision` combination being rejected in `upload_folder`.
+            pr = self.api.create_pull_request(
+                repo_id=self.repo_id,
+                title=self.commit_message,
+                token=self.token,
+                description=self.commit_description,
+                repo_type=self.repo_type,
+            )
+            if pr.git_reference is None:
+                raise ValueError("Server did not return a git reference for the created pull request.")
+            self.pr_url = pr.url
+            self.pr_revision = pr.git_reference
+            self.commit_revision_quoted = quote(pr.git_reference, safe="")
+
+        operations: list[Any] = list(ops)
+        if self.nb_commits == 0:
+            # Deletions and `parent_commit` ride the first commit.
+            operations = list(self.delete_operations) + operations
+
+        commit_message = (
+            self.commit_message if self.nb_commits == 0 else f"{self.commit_message} (part {self.nb_commits + 1})"
+        )
+        t0 = time.monotonic()
+        # Retried with backoff on transient errors: safe because the commit targets an explicit
+        # ref (`?create_pr=1` is never used, see above).
+        self.last_commit_info = _send_commit(
+            operations=operations,
+            files_to_copy={},
+            commit_message=commit_message,
+            commit_description=self.commit_description or "",
+            repo_type=self.repo_type,
+            repo_id=self.repo_id,
+            headers=self.headers,
+            revision=self.commit_revision_quoted,
+            endpoint=self.api.endpoint,
+            parent_commit=self.parent_commit if self.nb_commits == 0 else None,
+            retry_on_error=True,
+        )
+        duration = time.monotonic() - t0
+        self.pacer.record_success(duration, len(ops))
+        self.nb_commits += 1
+
+        for op in ops:
+            op._is_committed = True
+        self.display.notify_commit(len(ops))
+        logger.debug(f"Committed {len(ops)} file(s) in {duration:.1f}s: {self.last_commit_info.commit_url}")
+
+    # ---------------------------------------------------------------- result
+
+    def _final_commit_info(self) -> "CommitInfo":
+        from .hf_api import CommitInfo
+
+        if self.last_commit_info is None:
+            # Nothing was committed (everything unchanged/ignored): mimic `create_commit` and
+            # return info about the latest commit on the target revision.
+            logger.warning("No files have been modified since last commit. Skipping to prevent empty commit.")
+            info = self.api.repo_info(repo_id=self.repo_id, repo_type=self.repo_type, revision=self.revision)
+            url_prefix = self.api.endpoint
+            if self.repo_type != constants.REPO_TYPE_MODEL:
+                url_prefix = f"{url_prefix}/{self.repo_type}s"
+            return CommitInfo(
+                commit_url=f"{url_prefix}/{self.repo_id}/commit/{info.sha}",
+                commit_message=self.commit_message,
+                commit_description=self.commit_description or "",
+                oid=info.sha,  # type: ignore
+                _endpoint=self.api.endpoint,
+            )
+        if self.nb_commits > 1:
+            logger.info(f"Upload completed in {self.nb_commits} commits.")
+        if self.pr_url is not None:
+            # PR upload: attach the PR info (commit responses don't carry it; the PR is created separately).
+            return CommitInfo(
+                commit_url=self.last_commit_info.commit_url,
+                commit_message=self.last_commit_info.commit_message,
+                commit_description=self.last_commit_info.commit_description,
+                oid=self.last_commit_info.oid,
+                pr_url=self.pr_url,
+                _endpoint=self.api.endpoint,
+            )
+        return self.last_commit_info
+
+
+def pipelined_upload(
+    api: "HfApi",
+    *,
+    repo_id: str,
+    repo_type: str,
+    add_operations: list[CommitOperationAdd],
+    delete_operations: list[CommitOperationDelete],
+    commit_message: str,
+    commit_description: str | None = None,
+    token: str | bool | None = None,
+    revision: str | None = None,
+    create_pr: bool = False,
+    parent_commit: str | None = None,
+) -> "CommitInfo":
+    """Upload a prepared list of operations through the streamed multi-commit pipeline.
+
+    Requires `hf_xet` to be installed. See module docstring for the architecture.
+    """
+
+    return _UploadPipeline(
+        api,
+        repo_id=repo_id,
+        repo_type=repo_type,
+        add_operations=add_operations,
+        delete_operations=delete_operations,
+        commit_message=commit_message,
+        commit_description=commit_description,
+        token=token,
+        revision=revision,
+        create_pr=create_pr,
+        parent_commit=parent_commit,
+    ).run()

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_webhooks_payload.py

@@ -0,0 +1,136 @@
+# Copyright 2023-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 data structures to parse the webhooks payload."""
+
+from typing import Literal
+
+from .utils import is_pydantic_available
+
+
+if is_pydantic_available():
+    from pydantic import BaseModel
+else:
+    # Define a dummy BaseModel to avoid import errors when pydantic is not installed
+    # Import error will be raised when trying to use the class
+
+    class BaseModel:  # type: ignore [no-redef]
+        def __init__(self, *args, **kwargs) -> None:
+            raise ImportError(
+                "You must have `pydantic` installed to use `WebhookPayload`. This is an optional dependency that"
+                " should be installed separately. Please run `pip install --upgrade pydantic` and retry."
+            )
+
+
+# This is an adaptation of the ReportV3 interface implemented in moon-landing. V0, V1 and V2 have been ignored as they
+# are not in used anymore. To keep in sync when format is updated in
+# https://github.com/huggingface/moon-landing/blob/main/server/lib/HFWebhooks.ts (internal link).
+
+
+WebhookEvent_T = Literal[
+    "create",
+    "delete",
+    "move",
+    "update",
+]
+RepoChangeEvent_T = Literal[
+    "add",
+    "move",
+    "remove",
+    "update",
+]
+RepoType_T = Literal[
+    "dataset",
+    "model",
+    "space",
+]
+DiscussionStatus_T = Literal[
+    "closed",
+    "draft",
+    "open",
+    "merged",
+]
+SupportedWebhookVersion = Literal[3]
+
+
+class ObjectId(BaseModel):
+    id: str
+
+
+class WebhookPayloadUrl(BaseModel):
+    web: str
+    api: str | None = None
+
+
+class WebhookPayloadMovedTo(BaseModel):
+    name: str
+    owner: ObjectId
+
+
+class WebhookPayloadWebhook(ObjectId):
+    version: SupportedWebhookVersion
+
+
+class WebhookPayloadEvent(BaseModel):
+    action: WebhookEvent_T
+    scope: str
+
+
+class WebhookPayloadDiscussionChanges(BaseModel):
+    base: str
+    mergeCommitId: str | None = None
+
+
+class WebhookPayloadComment(ObjectId):
+    author: ObjectId
+    hidden: bool
+    content: str | None = None
+    url: WebhookPayloadUrl
+
+
+class WebhookPayloadDiscussion(ObjectId):
+    num: int
+    author: ObjectId
+    url: WebhookPayloadUrl
+    title: str
+    isPullRequest: bool
+    status: DiscussionStatus_T
+    changes: WebhookPayloadDiscussionChanges | None = None
+    pinned: bool | None = None
+
+
+class WebhookPayloadRepo(ObjectId):
+    owner: ObjectId
+    head_sha: str | None = None
+    name: str
+    private: bool
+    subdomain: str | None = None
+    tags: list[str] | None = None
+    type: Literal["dataset", "model", "space"]
+    url: WebhookPayloadUrl
+
+
+class WebhookPayloadUpdatedRef(BaseModel):
+    ref: str
+    oldSha: str | None = None
+    newSha: str | None = None
+
+
+class WebhookPayload(BaseModel):
+    event: WebhookPayloadEvent
+    repo: WebhookPayloadRepo
+    discussion: WebhookPayloadDiscussion | None = None
+    comment: WebhookPayloadComment | None = None
+    webhook: WebhookPayloadWebhook
+    movedTo: WebhookPayloadMovedTo | None = None
+    updatedRefs: list[WebhookPayloadUpdatedRef] | None = None

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/_webhooks_server.py

@@ -0,0 +1,376 @@
+# Copyright 2023-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 `WebhooksServer` and `webhook_endpoint` to create a webhook server easily."""
+
+import atexit
+import inspect
+import os
+from collections.abc import Callable
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Optional
+
+from .utils import experimental, is_fastapi_available, is_gradio_available
+
+
+if TYPE_CHECKING:
+    import gradio as gr
+    from fastapi import Request
+
+if is_fastapi_available():
+    from fastapi import FastAPI, Request
+    from fastapi.responses import JSONResponse
+else:
+    # Will fail at runtime if FastAPI is not available
+    FastAPI = Request = JSONResponse = None  # type: ignore
+
+
+_global_app: Optional["WebhooksServer"] = None  # ty: ignore[invalid-type-form]
+_is_local = os.environ.get("SPACE_ID") is None
+
+
+@experimental
+class WebhooksServer:
+    """
+    The [`WebhooksServer`] class lets you create an instance of a Gradio app that can receive Huggingface webhooks.
+    These webhooks can be registered using the [`~WebhooksServer.add_webhook`] decorator. Webhook endpoints are added to
+    the app as a POST endpoint to the FastAPI router. Once all the webhooks are registered, the `launch` method has to be
+    called to start the app.
+
+    It is recommended to accept [`WebhookPayload`] as the first argument of the webhook function. It is a Pydantic
+    model that contains all the information about the webhook event. The data will be parsed automatically for you.
+
+    Check out the [webhooks guide](../guides/webhooks_server) for a step-by-step tutorial on how to set up your
+    WebhooksServer and deploy it on a Space.
+
+    > [!WARNING]
+    > `WebhooksServer` is experimental. Its API is subject to change in the future.
+
+    > [!WARNING]
+    > You must have `gradio` installed to use `WebhooksServer` (`pip install --upgrade gradio`).
+
+    Args:
+        ui (`gradio.Blocks`, optional):
+            A Gradio UI instance to be used as the Space landing page. If `None`, a UI displaying instructions
+            about the configured webhooks is created.
+        webhook_secret (`str`, optional):
+            A secret key to verify incoming webhook requests. You can set this value to any secret you want as long as
+            you also configure it in your [webhooks settings panel](https://huggingface.co/settings/webhooks). You
+            can also set this value as the `WEBHOOK_SECRET` environment variable. If no secret is provided, the
+            webhook endpoints are opened without any security.
+
+    Example:
+
+        ```python
+        import gradio as gr
+        from huggingface_hub import WebhooksServer, WebhookPayload
+
+        with gr.Blocks() as ui:
+            ...
+
+        app = WebhooksServer(ui=ui, webhook_secret="my_secret_key")
+
+        @app.add_webhook("/say_hello")
+        async def hello(payload: WebhookPayload):
+            return {"message": "hello"}
+
+        app.launch()
+        ```
+    """
+
+    def __new__(cls, *args, **kwargs) -> "WebhooksServer":  # ty: ignore[invalid-type-form]
+        if not is_gradio_available():
+            raise ImportError(
+                "You must have `gradio` installed to use `WebhooksServer`. Please run `pip install --upgrade gradio`"
+                " first."
+            )
+        if not is_fastapi_available():
+            raise ImportError(
+                "You must have `fastapi` installed to use `WebhooksServer`. Please run `pip install --upgrade fastapi`"
+                " first."
+            )
+        return super().__new__(cls)
+
+    def __init__(
+        self,
+        ui: Optional["gr.Blocks"] = None,
+        webhook_secret: str | None = None,
+    ) -> None:
+        self._ui = ui
+
+        self.webhook_secret = webhook_secret or os.getenv("WEBHOOK_SECRET")
+        self.registered_webhooks: dict[str, Callable] = {}
+        _warn_on_empty_secret(self.webhook_secret)
+
+    def add_webhook(self, path: str | None = None) -> Callable:
+        """
+        Decorator to add a webhook to the [`WebhooksServer`] server.
+
+        Args:
+            path (`str`, optional):
+                The URL path to register the webhook function. If not provided, the function name will be used as the
+                path. In any case, all webhooks are registered under `/webhooks`.
+
+        Raises:
+            ValueError: If the provided path is already registered as a webhook.
+
+        Example:
+            ```python
+            from huggingface_hub import WebhooksServer, WebhookPayload
+
+            app = WebhooksServer()
+
+            @app.add_webhook
+            async def trigger_training(payload: WebhookPayload):
+                if payload.repo.type == "dataset" and payload.event.action == "update":
+                    # Trigger a training job if a dataset is updated
+                    ...
+
+            app.launch()
+        ```
+        """
+        # Usage: directly as decorator. Example: `@app.add_webhook`
+        if callable(path):
+            # If path is a function, it means it was used as a decorator without arguments
+            return self.add_webhook()(path)
+
+        # Usage: provide a path. Example: `@app.add_webhook(...)`
+        @wraps(FastAPI.post)
+        def _inner_post(*args, **kwargs):
+            func = args[0]
+            abs_path = f"/webhooks/{(path or func.__name__).strip('/')}"
+            if abs_path in self.registered_webhooks:
+                raise ValueError(f"Webhook {abs_path} already exists.")
+            self.registered_webhooks[abs_path] = func
+
+        return _inner_post
+
+    def launch(self, prevent_thread_lock: bool = False, **launch_kwargs: Any) -> None:
+        """Launch the Gradio app and register webhooks to the underlying FastAPI server.
+
+        Input parameters are forwarded to Gradio when launching the app.
+        """
+        ui = self._ui or self._get_default_ui()
+
+        # Start Gradio App
+        #   - as non-blocking so that webhooks can be added afterwards
+        #   - as shared if launch locally (to debug webhooks)
+        launch_kwargs.setdefault("share", _is_local)
+        self.fastapi_app, _, _ = ui.launch(prevent_thread_lock=True, **launch_kwargs)
+
+        # Register webhooks to FastAPI app
+        for path, func in self.registered_webhooks.items():
+            # Add secret check if required
+            if self.webhook_secret is not None:
+                func = _wrap_webhook_to_check_secret(func, webhook_secret=self.webhook_secret)
+
+            # Add route to FastAPI app
+            self.fastapi_app.post(path)(func)
+
+        # Print instructions and block main thread
+        space_host = os.environ.get("SPACE_HOST")
+        url = "https://" + space_host if space_host is not None else (ui.share_url or ui.local_url)
+        if url is None:
+            raise ValueError("Cannot find the URL of the app. Please provide a valid `ui` or update `gradio` version.")
+        url = url.strip("/")
+        message = "\nWebhooks are correctly setup and ready to use:"
+        message += "\n" + "\n".join(f"  - POST {url}{webhook}" for webhook in self.registered_webhooks)
+        message += "\nGo to https://huggingface.co/settings/webhooks to setup your webhooks."
+        print(message)
+
+        if not prevent_thread_lock:
+            ui.block_thread()
+
+    def _get_default_ui(self) -> "gr.Blocks":
+        """Default UI if not provided (lists webhooks and provides basic instructions)."""
+        import gradio as gr
+
+        with gr.Blocks() as ui:
+            gr.Markdown("# This is an app to process 🤗 Webhooks")
+            gr.Markdown(
+                "Webhooks are a foundation for MLOps-related features. They allow you to listen for new changes on"
+                " specific repos or to all repos belonging to particular set of users/organizations (not just your"
+                " repos, but any repo). Check out this [guide](https://huggingface.co/docs/hub/webhooks) to get to"
+                " know more about webhooks on the Huggingface Hub."
+            )
+            gr.Markdown(
+                f"{len(self.registered_webhooks)} webhook(s) are registered:"
+                + "\n\n"
+                + "\n ".join(
+                    f"- [{webhook_path}]({_get_webhook_doc_url(webhook.__name__, webhook_path)})"
+                    for webhook_path, webhook in self.registered_webhooks.items()
+                )
+            )
+            gr.Markdown(
+                "Go to https://huggingface.co/settings/webhooks to setup your webhooks."
+                + "\nYou app is running locally. Please look at the logs to check the full URL you need to set."
+                if _is_local
+                else (
+                    "\nThis app is running on a Space. You can find the corresponding URL in the options menu"
+                    " (top-right) > 'Embed the Space'. The URL looks like 'https://{username}-{repo_name}.hf.space'."
+                )
+            )
+        return ui
+
+
+@experimental
+def webhook_endpoint(path: str | None = None) -> Callable:
+    """Decorator to start a [`WebhooksServer`] and register the decorated function as a webhook endpoint.
+
+    This is a helper to get started quickly. If you need more flexibility (custom landing page or webhook secret),
+    you can use [`WebhooksServer`] directly. You can register multiple webhook endpoints (to the same server) by using
+    this decorator multiple times.
+
+    Check out the [webhooks guide](../guides/webhooks_server) for a step-by-step tutorial on how to set up your
+    server and deploy it on a Space.
+
+    > [!WARNING]
+    > `webhook_endpoint` is experimental. Its API is subject to change in the future.
+
+    > [!WARNING]
+    > You must have `gradio` installed to use `webhook_endpoint` (`pip install --upgrade gradio`).
+
+    Args:
+        path (`str`, optional):
+            The URL path to register the webhook function. If not provided, the function name will be used as the path.
+            In any case, all webhooks are registered under `/webhooks`.
+
+    Examples:
+        The default usage is to register a function as a webhook endpoint. The function name will be used as the path.
+        The server will be started automatically at exit (i.e. at the end of the script).
+
+        ```python
+        from huggingface_hub import webhook_endpoint, WebhookPayload
+
+        @webhook_endpoint
+        async def trigger_training(payload: WebhookPayload):
+            if payload.repo.type == "dataset" and payload.event.action == "update":
+                # Trigger a training job if a dataset is updated
+                ...
+
+        # Server is automatically started at the end of the script.
+        ```
+
+        Advanced usage: register a function as a webhook endpoint and start the server manually. This is useful if you
+        are running it in a notebook.
+
+        ```python
+        from huggingface_hub import webhook_endpoint, WebhookPayload
+
+        @webhook_endpoint
+        async def trigger_training(payload: WebhookPayload):
+            if payload.repo.type == "dataset" and payload.event.action == "update":
+                # Trigger a training job if a dataset is updated
+                ...
+
+        # Start the server manually
+        trigger_training.launch()
+        ```
+    """
+    if callable(path):
+        # If path is a function, it means it was used as a decorator without arguments
+        return webhook_endpoint()(path)
+
+    @wraps(WebhooksServer.add_webhook)
+    def _inner(func: Callable) -> Callable:
+        app = _get_global_app()
+        app.add_webhook(path)(func)
+        if len(app.registered_webhooks) == 1:
+            # Register `app.launch` to run at exit (only once)
+            atexit.register(app.launch)
+
+        @wraps(app.launch)
+        def _launch_now():
+            # Run the app directly (without waiting atexit)
+            atexit.unregister(app.launch)
+            app.launch()
+
+        func.launch = _launch_now  # type: ignore
+        return func
+
+    return _inner
+
+
+def _get_global_app() -> WebhooksServer:  # ty: ignore[invalid-type-form]
+    global _global_app
+    if _global_app is None:
+        _global_app = WebhooksServer()
+    return _global_app
+
+
+def _warn_on_empty_secret(webhook_secret: str | None) -> None:
+    if webhook_secret is None:
+        print("Webhook secret is not defined. This means your webhook endpoints will be open to everyone.")
+        print(
+            "To add a secret, set `WEBHOOK_SECRET` as environment variable or pass it at initialization: "
+            "\n\t`app = WebhooksServer(webhook_secret='my_secret', ...)`"
+        )
+        print(
+            "For more details about webhook secrets, please refer to"
+            " https://huggingface.co/docs/hub/webhooks#webhook-secret."
+        )
+    else:
+        print("Webhook secret is correctly defined.")
+
+
+def _get_webhook_doc_url(webhook_name: str, webhook_path: str) -> str:
+    """Returns the anchor to a given webhook in the docs (experimental)"""
+    return "/docs#/default/" + webhook_name + webhook_path.replace("/", "_") + "_post"
+
+
+def _wrap_webhook_to_check_secret(func: Callable, webhook_secret: str) -> Callable:
+    """Wraps a webhook function to check the webhook secret before calling the function.
+
+    This is a hacky way to add the `request` parameter to the function signature. Since FastAPI based itself on route
+    parameters to inject the values to the function, we need to hack the function signature to retrieve the `Request`
+    object (and hence the headers). A far cleaner solution would be to use a middleware. However, since
+    `fastapi==0.90.1`, a middleware cannot be added once the app has started. And since the FastAPI app is started by
+    Gradio internals (and not by us), we cannot add a middleware.
+
+    This method is called only when a secret has been defined by the user. If a request is sent without the
+    "x-webhook-secret", the function will return a 401 error (unauthorized). If the header is sent but is incorrect,
+    the function will return a 403 error (forbidden).
+
+    Inspired by https://stackoverflow.com/a/33112180.
+    """
+    initial_sig = inspect.signature(func)
+
+    @wraps(func)
+    async def _protected_func(request: Request, **kwargs):
+        request_secret = request.headers.get("x-webhook-secret")
+        if request_secret is None:
+            return JSONResponse({"error": "x-webhook-secret header not set."}, status_code=401)
+        if request_secret != webhook_secret:
+            return JSONResponse({"error": "Invalid webhook secret."}, status_code=403)
+
+        # Inject `request` in kwargs if required
+        if "request" in initial_sig.parameters:
+            kwargs["request"] = request
+
+        # Handle both sync and async routes
+        if inspect.iscoroutinefunction(func):
+            return await func(**kwargs)
+        else:
+            return func(**kwargs)
+
+    # Update signature to include request
+    if "request" not in initial_sig.parameters:
+        _protected_func.__signature__ = initial_sig.replace(  # type: ignore
+            parameters=(
+                inspect.Parameter(name="request", kind=inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=Request),
+            )
+            + tuple(initial_sig.parameters.values())
+        )
+
+    # Return protected route
+    return _protected_func

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/__init__.py

@@ -0,0 +1,14 @@
+# 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.
+from huggingface_hub.cli._output import out  # noqa: F401

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/_city_game.py

@@ -0,0 +1,661 @@
+"""Interactive isometric city explorer — easter egg for `hf repos ls --explore`."""
+
+import dataclasses
+import math
+import os
+import random
+import re
+import select
+import shutil
+import sys
+import time
+
+from huggingface_hub.hf_api import RepoStorageInfo
+
+from ._file_listing import format_size
+
+
+Color = tuple[int, int, int]
+
+# (top_face, left_face, right_face) — lighter to darker for 3D effect
+_TYPE_COLORS: dict[str, tuple[Color, Color, Color]] = {
+    "model": ((175, 148, 240), (138, 112, 208), (105, 80, 180)),
+    "dataset": ((245, 128, 128), (222, 92, 92), (190, 60, 60)),
+    "space": ((245, 175, 85), (218, 140, 55), (185, 110, 30)),
+    "bucket": ((112, 185, 242), (70, 150, 220), (40, 118, 192)),
+}
+_EXTRA_COLORS: tuple[Color, Color, Color] = ((168, 176, 188), (128, 136, 148), (90, 98, 110))
+_GRID_COLOR: Color = (178, 182, 190)
+
+_DX = 4  # isometric half-width (pixels)
+_DY = 2  # isometric half-height (pixels)
+_MAX_H = 16  # tallest tile (pixels)
+_MIN_H = 1
+_COLS = 6
+_EXT = 1  # grid extension beyond tiles
+_MAX_TILES = 30
+
+# Cursor sprite — pixel art arrow pointer
+_OUTLINE: Color = (30, 30, 30)
+_FILL: Color = (255, 255, 255)
+
+_CURSOR_GRID = [
+    "  X  ",
+    " XWX ",
+    "XWWWX",
+    " XWX ",
+    "  X  ",
+]
+_CURSOR_PALETTE: dict[str, Color] = {
+    "X": _OUTLINE,
+    "W": _FILL,
+}
+_CURSOR_H = len(_CURSOR_GRID)
+
+_MOVE_FRAMES = 8
+_MOVE_DELAY = 0.03
+_CURSOR_PAD = _CURSOR_H + 16
+_GAP = 3
+_MIN_TERM_W = 100
+_MIN_TERM_H = 24
+_SUMMARY_W = 24
+
+
+# ---------------------------------------------------------------------------
+# Data structures
+# ---------------------------------------------------------------------------
+
+
+@dataclasses.dataclass
+class TileInfo:
+    grid_row: int
+    grid_col: int
+    height: int
+    top: Color
+    left: Color
+    right: Color
+    repo: RepoStorageInfo | None
+
+
+@dataclasses.dataclass
+class CityData:
+    tiles: list[TileInfo]
+    rows: int
+    cols: int
+    x_off: int
+    y_off: int
+    buf_w: int
+    buf_h: int
+    total_storage: int
+    extra_count: int
+    extra_storage: int
+    all_repos: list[RepoStorageInfo]
+
+
+# ---------------------------------------------------------------------------
+# City layout
+# ---------------------------------------------------------------------------
+
+
+def _prepare_city_data(repos: list[RepoStorageInfo]) -> CityData:
+    sorted_repos = sorted(repos, key=lambda r: r.storage, reverse=True)
+    display = sorted_repos[:_MAX_TILES]
+    extra_count = max(0, len(sorted_repos) - _MAX_TILES)
+    extra_storage = sum(r.storage for r in sorted_repos[_MAX_TILES:])
+    total_storage = sum(r.storage for r in repos)
+    max_storage = max(1, display[0].storage)
+
+    n = len(display) + (1 if extra_count > 0 else 0)
+    cols = min(n, _COLS)
+    rows = math.ceil(n / cols) if cols > 0 else 1
+
+    tiles: list[TileInfo] = []
+    for i, repo in enumerate(display):
+        r, c = divmod(i, cols)
+        h = max(_MIN_H, round(math.sqrt(repo.storage / max_storage) * _MAX_H))
+        top, left, right = _TYPE_COLORS.get(repo.type, _EXTRA_COLORS)
+        tiles.append(TileInfo(r, c, h, top, left, right, repo))
+    if extra_count > 0:
+        r, c = divmod(len(display), cols)
+        h = max(_MIN_H, round(math.sqrt(extra_storage / max_storage) * _MAX_H))
+        tiles.append(TileInfo(r, c, h, *_EXTRA_COLORS, None))
+
+    r_lo, r_hi = -_EXT, rows - 1 + _EXT
+    c_lo, c_hi = -_EXT, cols - 1 + _EXT
+
+    xs: list[int] = []
+    ys: list[int] = []
+    for rr in range(r_lo, r_hi + 1):
+        for cc in range(c_lo, c_hi + 1):
+            cx, cy = (cc - rr) * _DX, (cc + rr) * _DY
+            xs.extend([cx - _DX, cx + _DX])
+            ys.extend([cy, cy + 2 * _DY])
+    for tile in tiles:
+        ys.append((tile.grid_col + tile.grid_row) * _DY - tile.height)
+
+    x_off = -min(xs)
+    y_off = -min(ys)
+    buf_w = max(xs) - min(xs) + 1
+    buf_h = max(ys) - min(ys) + 1
+    if buf_h % 2:
+        buf_h += 1
+
+    return CityData(
+        tiles=tiles,
+        rows=rows,
+        cols=cols,
+        x_off=x_off,
+        y_off=y_off,
+        buf_w=buf_w,
+        buf_h=buf_h,
+        total_storage=total_storage,
+        extra_count=extra_count,
+        extra_storage=extra_storage,
+        all_repos=repos,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Drawing primitives
+# ---------------------------------------------------------------------------
+
+
+def _draw_diamond_outline(buf: list[list[Color | None]], cx: int, cy: int) -> None:
+    t = (cx, cy)
+    r = (cx + _DX, cy + _DY)
+    b = (cx, cy + 2 * _DY)
+    ll = (cx - _DX, cy + _DY)
+    _draw_line(buf, *t, *r, _GRID_COLOR)
+    _draw_line(buf, *r, *b, _GRID_COLOR)
+    _draw_line(buf, *b, *ll, _GRID_COLOR)
+    _draw_line(buf, *ll, *t, _GRID_COLOR)
+
+
+def _draw_block(
+    buf: list[list[Color | None]],
+    cx: int,
+    cy: int,
+    h: int,
+    top: Color,
+    left: Color,
+    right: Color,
+) -> None:
+    _fill_poly(
+        buf,
+        [(cx - _DX, cy + _DY - h), (cx, cy + 2 * _DY - h), (cx, cy + 2 * _DY), (cx - _DX, cy + _DY)],
+        left,
+    )
+    _fill_poly(
+        buf,
+        [(cx, cy + 2 * _DY - h), (cx + _DX, cy + _DY - h), (cx + _DX, cy + _DY), (cx, cy + 2 * _DY)],
+        right,
+    )
+    _fill_poly(
+        buf,
+        [(cx, cy - h), (cx + _DX, cy + _DY - h), (cx, cy + 2 * _DY - h), (cx - _DX, cy + _DY - h)],
+        top,
+    )
+
+
+def _fill_poly(buf: list[list[Color | None]], verts: list[tuple[int, int]], color: Color) -> None:
+    bh = len(buf)
+    bw = len(buf[0]) if buf else 0
+    all_y = [v[1] for v in verts]
+    y0 = max(0, min(all_y))
+    y1 = min(bh - 1, max(all_y))
+    n = len(verts)
+    for y in range(y0, y1 + 1):
+        xl: float = float("inf")
+        xr: float = float("-inf")
+        for i in range(n):
+            ax, ay = verts[i]
+            bx, by = verts[(i + 1) % n]
+            if ay == by:
+                if y == ay:
+                    xl = min(xl, float(min(ax, bx)))
+                    xr = max(xr, float(max(ax, bx)))
+                continue
+            if not (min(ay, by) <= y <= max(ay, by)):
+                continue
+            t = (y - ay) / (by - ay)
+            ix = ax + t * (bx - ax)
+            xl = min(xl, ix)
+            xr = max(xr, ix)
+        if xl <= xr:
+            for x in range(max(0, round(xl)), min(bw, round(xr) + 1)):
+                buf[y][x] = color
+
+
+def _draw_line(buf: list[list[Color | None]], x0: int, y0: int, x1: int, y1: int, color: Color) -> None:
+    bh = len(buf)
+    bw = len(buf[0]) if buf else 0
+    dx = abs(x1 - x0)
+    dy = abs(y1 - y0)
+    steps = max(dx, dy)
+    if steps == 0:
+        if 0 <= y0 < bh and 0 <= x0 < bw:
+            buf[y0][x0] = color
+        return
+    xi = (x1 - x0) / steps
+    yi = (y1 - y0) / steps
+    fx, fy = float(x0), float(y0)
+    for _ in range(steps + 1):
+        px, py = round(fx), round(fy)
+        if 0 <= py < bh and 0 <= px < bw:
+            buf[py][px] = color
+        fx += xi
+        fy += yi
+
+
+# ---------------------------------------------------------------------------
+# Pixel buffer → terminal
+# ---------------------------------------------------------------------------
+
+_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
+
+
+def _strip_ansi(s: str) -> str:
+    return _ANSI_RE.sub("", s)
+
+
+def _visible_len(s: str) -> int:
+    return len(_strip_ansi(s))
+
+
+def _pixels_to_lines(buf: list[list[Color | None]]) -> list[str]:
+    height = len(buf)
+    width = len(buf[0]) if buf else 0
+    lines: list[str] = []
+    for row in range(0, height, 2):
+        last = -1
+        for col in range(width - 1, -1, -1):
+            top = buf[row][col]
+            bot = buf[row + 1][col] if row + 1 < height else None
+            if top or bot:
+                last = col
+                break
+        if last < 0:
+            lines.append("")
+            continue
+
+        parts: list[str] = []
+        cfg: Color | None = None
+        cbg: Color | None = None
+
+        for col in range(last + 1):
+            top = buf[row][col]
+            bot = buf[row + 1][col] if row + 1 < height else None
+
+            if not top and not bot:
+                if cfg is not None or cbg is not None:
+                    parts.append("\033[0m")
+                    cfg = cbg = None
+                parts.append(" ")
+                continue
+
+            if top and bot and top == bot:
+                nfg, nbg, ch = top, None, "█"
+            elif top and bot:
+                nfg, nbg, ch = bot, top, "▄"
+            elif top:
+                nfg, nbg, ch = top, None, "▀"
+            else:
+                nfg, nbg, ch = bot, None, "▄"  # type: ignore[assignment]
+
+            esc = ""
+            if nfg != cfg:
+                esc += f"\033[38;2;{nfg[0]};{nfg[1]};{nfg[2]}m"
+                cfg = nfg
+            if nbg != cbg:
+                esc += "\033[49m" if nbg is None else f"\033[48;2;{nbg[0]};{nbg[1]};{nbg[2]}m"
+                cbg = nbg
+            parts.append(esc + ch)
+
+        if cfg is not None or cbg is not None:
+            parts.append("\033[0m")
+        lines.append("".join(parts))
+    return lines
+
+
+# ---------------------------------------------------------------------------
+# Rendering
+# ---------------------------------------------------------------------------
+
+
+def _render_base_buffer(city: CityData) -> list[list[Color | None]]:
+    buf: list[list[Color | None]] = [[None] * city.buf_w for _ in range(city.buf_h)]
+
+    for tile in city.tiles:
+        cx = city.x_off + (tile.grid_col - tile.grid_row) * _DX
+        cy = city.y_off + (tile.grid_col + tile.grid_row) * _DY
+        _draw_diamond_outline(buf, cx, cy)
+
+    sorted_tiles = sorted(city.tiles, key=lambda t: (t.grid_row + t.grid_col, t.grid_col))
+    for tile in sorted_tiles:
+        cx = city.x_off + (tile.grid_col - tile.grid_row) * _DX
+        cy = city.y_off + (tile.grid_col + tile.grid_row) * _DY
+        _draw_block(buf, cx, cy, tile.height, tile.top, tile.left, tile.right)
+
+    return buf
+
+
+# ---------------------------------------------------------------------------
+# Summary panel
+# ---------------------------------------------------------------------------
+
+
+def _colored_square(color: Color) -> str:
+    return f"\033[38;2;{color[0]};{color[1]};{color[2]}m■\033[0m"
+
+
+def _build_summary(
+    repos: list[RepoStorageInfo],
+    total_storage: int,
+    extra_count: int,
+) -> list[str]:
+    lines: list[str] = [""]
+    lines.append("  Storage Overview")
+    lines.append("  " + "─" * 16)
+    lines.append(f"  {format_size(total_storage, human_readable=True)} total")
+    lines.append("")
+
+    order = ["model", "dataset", "space", "bucket"]
+    labels = {"model": "Models", "dataset": "Datasets", "space": "Spaces", "bucket": "Buckets"}
+    for rtype in order:
+        group = [r for r in repos if r.type == rtype]
+        if not group:
+            continue
+        storage = sum(r.storage for r in group)
+        sq = _colored_square(_TYPE_COLORS[rtype][0])
+        lines.append(f"  {sq} {labels[rtype]}")
+        lines.append(f"    {len(group)} repos · {format_size(storage, human_readable=True)}")
+        lines.append("")
+
+    if extra_count > 0:
+        sq = _colored_square(_EXTRA_COLORS[0])
+        lines.append(f"  {sq} +{extra_count} more repos")
+
+    return lines
+
+
+# ---------------------------------------------------------------------------
+# Cursor
+# ---------------------------------------------------------------------------
+
+
+def _build_cursor() -> list[tuple[int, int, Color]]:
+    pixels: list[tuple[int, int, Color]] = []
+    for ri, row in enumerate(_CURSOR_GRID):
+        for ci, ch in enumerate(row):
+            if ch in _CURSOR_PALETTE:
+                pixels.append((ci - len(row) // 2, ri - _CURSOR_H + 1, _CURSOR_PALETTE[ch]))
+    return pixels
+
+
+_CURSOR_PIXELS = _build_cursor()
+
+
+# ---------------------------------------------------------------------------
+# Interactive game
+# ---------------------------------------------------------------------------
+
+
+def run_city_game(repos: list[RepoStorageInfo]) -> None:
+    """Launch the interactive city explorer."""
+    if not repos:
+        print("No repositories found.")
+        return
+
+    try:
+        import termios
+        import tty
+    except ImportError:
+        print("Interactive mode requires a Unix-like terminal (Linux/macOS).")
+        return
+
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        print("Interactive mode requires a terminal.")
+        return
+
+    term = shutil.get_terminal_size()
+    if term.columns < _MIN_TERM_W or term.lines < _MIN_TERM_H:
+        print(f"Your terminal is {term.columns}×{term.lines} characters.")
+        print(f"Please resize to at least {_MIN_TERM_W}×{_MIN_TERM_H} to explore the city!")
+        return
+
+    city = _prepare_city_data(repos)
+
+    tiles_with_repos = [t for t in city.tiles if t.repo is not None]
+    start_tile = random.choice(tiles_with_repos) if tiles_with_repos else city.tiles[0]
+
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+    try:
+        tty.setraw(fd)
+        sys.stdout.write("\033[?1049h\033[?25l\033[2J")
+        sys.stdout.flush()
+        _game_loop(city, start_tile.grid_row, start_tile.grid_col)
+    finally:
+        sys.stdout.write("\033[?25h\033[?1049l")
+        sys.stdout.flush()
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+
+def _game_loop(city: CityData, cur_row: int, cur_col: int) -> None:
+    tile_map: dict[tuple[int, int], TileInfo] = {(t.grid_row, t.grid_col): t for t in city.tiles}
+    city = dataclasses.replace(city, buf_h=city.buf_h + _CURSOR_PAD, y_off=city.y_off + _CURSOR_PAD)
+    base_buf = _render_base_buffer(city)
+
+    summary = _build_summary(city.all_repos, city.total_storage, city.extra_count)
+
+    # Intro: cursor drops onto starting tile
+    tx, ty = _tile_top_center(city, cur_row, cur_col, tile_map)
+    for i in range(1, _MOVE_FRAMES + 1):
+        t = i / _MOVE_FRAMES
+        t = t * t * (3 - 2 * t)
+        drop_y = ty - 16 * (1 - t)
+        frame = _copy_buf(base_buf)
+        _highlight_tile(frame, city, tile_map[(cur_row, cur_col)])
+        _draw_cursor(frame, tx, round(drop_y))
+        _present(city, frame, tile_map.get((cur_row, cur_col)), summary)
+        time.sleep(_MOVE_DELAY)
+
+    while True:
+        cx, cy = _tile_top_center(city, cur_row, cur_col, tile_map)
+        frame = _copy_buf(base_buf)
+        _highlight_tile(frame, city, tile_map[(cur_row, cur_col)])
+        _draw_cursor(frame, cx, cy)
+        _present(city, frame, tile_map.get((cur_row, cur_col)), summary)
+
+        key = _read_key()
+        if key in ("q", "Q", "esc", "\x03"):
+            return
+
+        dr, dc = _key_to_direction(key)
+        if dr == 0 and dc == 0:
+            continue
+
+        nr, nc = cur_row + dr, cur_col + dc
+        if (nr, nc) not in tile_map:
+            continue
+
+        ex, ey = _tile_top_center(city, nr, nc, tile_map)
+        for i in range(1, _MOVE_FRAMES + 1):
+            t = i / _MOVE_FRAMES
+            t = t * t * (3 - 2 * t)
+            bx = cx + (ex - cx) * t
+            by = cy + (ey - cy) * t
+            frame = _copy_buf(base_buf)
+            _highlight_tile(frame, city, tile_map[(nr, nc)])
+            _draw_cursor(frame, round(bx), round(by))
+            _present(city, frame, tile_map.get((nr, nc)), summary)
+            time.sleep(_MOVE_DELAY)
+
+        cur_row, cur_col = nr, nc
+
+
+def _tile_top_center(city: CityData, row: int, col: int, tile_map: dict[tuple[int, int], TileInfo]) -> tuple[int, int]:
+    tile = tile_map.get((row, col))
+    h = tile.height if tile else 1
+    cx = city.x_off + (col - row) * _DX
+    cy = city.y_off + (col + row) * _DY
+    return cx, cy + _DY - h
+
+
+def _key_to_direction(key: str) -> tuple[int, int]:
+    match key:
+        case "w" | "W" | "\x1b[A":
+            return -1, 0
+        case "s" | "S" | "\x1b[B":
+            return 1, 0
+        case "a" | "A" | "\x1b[D":
+            return 0, -1
+        case "d" | "D" | "\x1b[C":
+            return 0, 1
+        case _:
+            return 0, 0
+
+
+def _draw_cursor(buf: list[list[Color | None]], cx: int, cy: int) -> None:
+    bh = len(buf)
+    bw = len(buf[0]) if buf else 0
+    for dx, dy, color in _CURSOR_PIXELS:
+        px, py = cx + dx, cy + dy
+        if 0 <= py < bh and 0 <= px < bw:
+            buf[py][px] = color
+
+
+def _highlight_tile(buf: list[list[Color | None]], city: CityData, tile: TileInfo) -> None:
+    cx = city.x_off + (tile.grid_col - tile.grid_row) * _DX
+    cy = city.y_off + (tile.grid_col + tile.grid_row) * _DY
+    h = tile.height
+    _fill_poly(
+        buf,
+        [(cx, cy - h), (cx + _DX, cy + _DY - h), (cx, cy + 2 * _DY - h), (cx - _DX, cy + _DY - h)],
+        _brighten(tile.top, 35),
+    )
+
+
+def _brighten(color: Color, amount: int) -> Color:
+    return (min(255, color[0] + amount), min(255, color[1] + amount), min(255, color[2] + amount))
+
+
+def _present(
+    city: CityData,
+    buf: list[list[Color | None]],
+    tile: TileInfo | None,
+    summary: list[str],
+) -> None:
+    city_lines = _pixels_to_lines(buf)
+    while city_lines and not _strip_ansi(city_lines[0]).strip():
+        city_lines.pop(0)
+    while city_lines and not _strip_ansi(city_lines[-1]).strip():
+        city_lines.pop()
+
+    city_w = max((_visible_len(line) for line in city_lines), default=0)
+    term = shutil.get_terminal_size()
+    panel_max_w = max(20, term.columns - city_w - _SUMMARY_W - 2 * _GAP)
+
+    info = _build_info_panel(tile, city, panel_max_w)
+
+    n = max(len(summary), len(city_lines), len(info))
+    summary_lo = max(0, (n - len(summary)) // 2)
+    info_lo = max(0, (n - len(info)) // 2)
+
+    lines: list[str] = []
+    for i in range(n):
+        si = i - summary_lo
+        lt = summary[si] if 0 <= si < len(summary) else ""
+        lpad = max(0, _SUMMARY_W - _visible_len(lt))
+
+        ct = city_lines[i] if i < len(city_lines) else ""
+        cpad = max(0, city_w - _visible_len(ct))
+
+        ri = i - info_lo
+        rt = info[ri] if 0 <= ri < len(info) else ""
+
+        lines.append(lt + " " * lpad + " " * _GAP + ct + " " * cpad + " " * _GAP + rt)
+
+    lines.append("")
+    lines.append("  \033[90mWASD/Arrows: move · Q/ESC: quit\033[0m")
+
+    while len(lines) < term.lines - 1:
+        lines.append("")
+
+    output = "\033[H"
+    for line in lines[: term.lines - 1]:
+        output += line + "\033[K\r\n"
+    sys.stdout.write(output)
+    sys.stdout.flush()
+
+
+def _build_info_panel(tile: TileInfo | None, city: CityData, max_w: int) -> list[str]:
+    reset = "\033[0m"
+    gray = "\033[90m"
+    bold = "\033[1m"
+    indent = "  "
+    content_w = max_w - len(indent)
+
+    lines: list[str] = [""]
+    lines.append(f"{indent}{bold}City Explorer{reset}")
+    lines.append(indent + "─" * min(22, content_w))
+    lines.append("")
+
+    if tile is None:
+        lines.append(f"{indent}{gray}Move to a tile")
+        lines.append(f"{indent}to see details.{reset}")
+        return lines
+
+    if tile.repo is None:
+        lines.append(f"{indent}{gray}+{city.extra_count} more repos{reset}")
+        lines.append(f"{indent}{gray}{format_size(city.extra_storage, human_readable=True)} combined{reset}")
+        return lines
+
+    repo = tile.repo
+    name = repo.id
+    if len(name) > content_w:
+        name = name[: content_w - 3] + "..."
+    lines.append(f"{indent}{bold}{name}{reset}")
+    lines.append("")
+
+    type_ansi = {
+        "model": "\033[38;2;175;148;240m",
+        "dataset": "\033[38;2;245;128;128m",
+        "space": "\033[38;2;245;175;85m",
+        "bucket": "\033[38;2;112;185;242m",
+    }
+    tc = type_ansi.get(repo.type, "")
+
+    lines.append(f"{indent}Type       {tc}{repo.type}{reset}")
+    lines.append(f"{indent}Visibility {repo.visibility}")
+    lines.append(f"{indent}Storage    {format_size(repo.storage, human_readable=True)}")
+    lines.append(f"{indent}Usage      {repo.storage_percent:.1f}%")
+    lines.append("")
+
+    bar_w = min(18, content_w)
+    filled = max(0, min(bar_w, round(repo.storage_percent / 100 * bar_w)))
+    lines.append(f"{indent}{tc}{'█' * filled}{gray}{'░' * (bar_w - filled)}{reset}")
+
+    return lines
+
+
+def _copy_buf(buf: list[list[Color | None]]) -> list[list[Color | None]]:
+    return [row[:] for row in buf]
+
+
+def _read_key() -> str:
+    fd = sys.stdin.fileno()
+    ch = os.read(fd, 1)
+    if ch == b"\x1b":
+        if _has_input(fd, 0.05):
+            ch2 = os.read(fd, 1)
+            if ch2 == b"[" and _has_input(fd, 0.05):
+                ch3 = os.read(fd, 1)
+                return f"\x1b[{ch3.decode()}"
+        return "esc"
+    return ch.decode("utf-8", errors="replace")
+
+
+def _has_input(fd: int, timeout: float) -> bool:
+    r, _, _ = select.select([fd], [], [], timeout)
+    return bool(r)

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/_cli_utils.py

@@ -0,0 +1,1069 @@
+# 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 difflib
+import importlib.metadata
+import os
+import re
+import shlex
+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, cast
+
+import click
+
+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,
+    parse_hf_mount,
+)
+from huggingface_hub.utils._dotenv import load_dotenv
+
+from ._framework import Argument, HfCommand, HfGroup, Option
+from ._help_formatter import StyledContext
+from ._output import OutputFormat, out
+
+
+logger = logging.get_logger()
+
+# 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(HfGroup):
+    """
+    CLI 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``, ``--no-truncate``)
+      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.
+    """
+
+    context_class = StyledContext
+
+    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)
+                    setattr(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 / --no-truncate) 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)
+
+    def command(  # type: ignore  # adds topic/examples on top of HfGroup.command
+        self,
+        name: str | None = None,
+        *,
+        topic: TOPIC_T = "main",
+        examples: list[str] | None = None,
+        epilog: str | None = None,
+        **kwargs: Any,
+    ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+        # Generate the epilog from examples when not provided explicitly, then build the
+        # command with a topic/examples-aware command class.
+        if epilog is None and examples:
+            epilog = generate_epilog(examples)
+        return super().command(name, cls=HFCliCommand(topic, examples), epilog=epilog, **kwargs)
+
+
+_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'."),
+    ("--no-truncate", "Do not truncate scalar values in human tables (list/dict columns stay shortened)."),
+]
+
+
+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 ls' 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 ls' 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'.
+
+    '--no-truncate' is stripped for all non-pass-through commands; when present, human table cells are not truncated.
+
+    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
+
+    no_truncate = _consume_no_truncate_flags(args)
+    out.set_no_truncate(no_truncate)
+
+    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: OutputFormat = OutputFormat.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 = OutputFormat.json
+            chosen_flag = "--json"
+            del args[i : i + 1]
+            continue
+        if arg in ("-q", "--quiet"):
+            _check_conflict(arg)
+            chosen_mode = OutputFormat.quiet
+            chosen_flag = arg
+            del args[i : i + 1]
+            continue
+        i += 1
+
+    out.set_mode(chosen_mode)
+
+
+def _consume_no_truncate_flags(args: list[str]) -> bool:
+    """Strip all global --no-truncate flags from args and return whether any was provided."""
+    no_truncate = False
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "--":
+            break  # everything after '--' is a positional literal
+        if arg == "--no-truncate":
+            no_truncate = True
+            del args[i : i + 1]
+            continue
+        if arg.startswith("--no-truncate="):
+            raise click.UsageError("Option '--no-truncate' does not take a value.")
+        i += 1
+    return no_truncate
+
+
+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 ls' 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) -> "OutputFormat":
+    try:
+        return OutputFormat(value)
+    except ValueError:
+        valid = ", ".join(m.value for m in OutputFormat)
+        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))}?")
+        setattr(error, "possibilities", [])
+    setattr(error, "message", 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[HfCommand]:
+    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: HfCommand, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        HfCommand.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 HfCommand.parse_args(self, ctx, args)
+
+    return type(
+        f"HfCommand{topic.capitalize()}",
+        (HfCommand,),
+        {
+            "context_class": StyledContext,
+            "topic": topic,
+            "examples": examples or [],
+            "format_epilog": format_epilog,
+            "format_options": format_options,
+            "parse_args": parse_args,
+        },
+    )
+
+
+def typer_factory(help: str, epilog: str | None = None, cls: type[HFCliTyperGroup] | None = None) -> "HFCliTyperGroup":
+    """Create a CLI command group with consistent settings.
+
+    The returned group is the app: register commands with ``@group.command(...)``,
+    subgroups with ``group.add_group(sub, name=...)``, and a group-level callback
+    with ``@group.callback(...)``.
+
+    Args:
+        help: Help text for the group.
+        epilog: Optional epilog text (use `generate_epilog` to create one).
+        cls: Optional group class to use (defaults to `HFCliTyperGroup`).
+
+    Returns:
+        A configured `HFCliTyperGroup` instance.
+    """
+    if cls is None:
+        cls = HFCliTyperGroup
+    return cls(
+        help=help,
+        epilog=epilog,
+        no_args_is_help=True,
+        # Increase max content width for better readability
+        context_settings={
+            "max_content_width": 120,
+            "help_option_names": ["-h", "--help"],
+        },
+    )
+
+
+class SoftChoice(click.Choice):
+    """A click Choice that suggests choices for autocompletion/docs but accepts any string.
+
+    Unlike `click.Choice`, unknown values are passed through as-is instead of raising an error.
+    This makes CLI options future-compatible when new server-side values are added.
+
+    Accepts either a sequence of strings or an Enum class:
+    ```python
+    SoftChoice(SpaceHardware)        # from an enum
+    SoftChoice(["a", "b", "c"])      # from a list
+    ```
+    """
+
+    def __init__(self, choices: Sequence[str] | type[Enum]) -> None:
+        values = (
+            [m.value for m in choices] if isinstance(choices, type) and issubclass(choices, Enum) else list(choices)
+        )
+        super().__init__(values, case_sensitive=True)
+
+    def convert(self, value: Any, param: click.Parameter | None, ctx: click.Context | None) -> str:
+        try:
+            return super().convert(value, param, ctx)
+        except click.exceptions.BadParameter:
+            return str(value)
+
+
+class RepoType(str, Enum):
+    model = "model"
+    dataset = "dataset"
+    space = "space"
+
+
+RepoIdArg = Annotated[
+    str,
+    Argument(
+        help="The ID of the repo (e.g. `username/repo-name` or `spaces/username/repo-name`).",
+    ),
+]
+
+
+RepoTypeOpt = Annotated[
+    RepoType,
+    Option(
+        "--type",
+        "--repo-type",
+        help="The type of repository (model, dataset, or space).",
+    ),
+]
+
+# Same as `RepoTypeOpt` but optional (defaults to `None` rather than `model`). Used by commands that
+# accept an `hf://` URI as repo id: a `None` default lets us tell apart "user did not pass --repo-type"
+# from "user explicitly passed --repo-type model", which is required to detect conflicts with the URI.
+RepoTypeOptionalOpt = Annotated[
+    RepoType | None,
+    Option(
+        "--type",
+        "--repo-type",
+        help="The type of repository (model, dataset, or space).",
+        show_default="model",
+    ),
+]
+
+TokenOpt = Annotated[
+    str | None,
+    Option(
+        help="A User Access Token generated from https://huggingface.co/settings/tokens.",
+    ),
+]
+
+PrivateOpt = Annotated[
+    bool | None,
+    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,
+    Option(
+        help="Git revision id which can be a branch name, a tag, or a commit hash.",
+    ),
+]
+
+
+LimitOpt = Annotated[
+    int,
+    Option(help="Limit the number of results."),
+]
+
+AuthorOpt = Annotated[
+    str | None,
+    Option(help="Filter by author or organization."),
+]
+
+FilterOpt = Annotated[
+    list[str] | None,
+    Option(help="Filter by tags (e.g. 'text-classification'). Can be used multiple times."),
+]
+
+SearchOpt = Annotated[
+    str | None,
+    Option(help="Search query."),
+]
+
+
+# --- Env / Secrets shared options and parsing helpers (used by jobs, repos, etc.) ---
+
+EnvOpt = Annotated[
+    list[str] | None,
+    Option(
+        "-e",
+        "--env",
+        help="Set environment variables. E.g. --env ENV=value",
+    ),
+]
+
+SecretsOpt = Annotated[
+    list[str] | None,
+    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,
+    Option(
+        "--env-file",
+        help="Read in a file of environment variables.",
+    ),
+]
+
+SecretsFileOpt = Annotated[
+    str | None,
+    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,
+    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",
+    ),
+]
+
+
+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:
+        mount = parse_hf_mount(raw_spec)
+        result.append(
+            Volume(
+                type=mount.source.type,
+                source=mount.source.id,
+                mount_path=mount.mount_path,
+                read_only=mount.read_only,
+                path=mount.source.path_in_repo or None,
+                revision=mount.source.revision or None,
+            )
+        )
+    return result
+
+
+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 click.BadParameter(
+                    f"Invalid expand property: '{prop}'. Valid values are: {', '.join(valid_properties)}"
+                )
+        return [cast(ExpandPropertyT, prop) for prop in properties]
+
+    return _parse_expand_properties
+
+
+### SSH
+
+
+SshIdentityFileOpt = Annotated[
+    Path | None,
+    Option("-i", "--identity-file", help="Path to the SSH identity file (forwarded to `ssh -i`)."),
+]
+
+SshDryRunOpt = Annotated[
+    bool,
+    Option("--dry-run", help="Print the SSH command instead of running it."),
+]
+
+
+def exec_ssh(
+    destination: str, *, port: int | None = None, identity_file: Path | None = None, dry_run: bool = False
+) -> None:
+    """Run an interactive `ssh` command to `destination` (`user@host`) and exit with its return code.
+
+    With `dry_run`, print the command instead of running it.
+    """
+    cmd = ["ssh"]
+    if identity_file is not None:
+        cmd += ["-i", str(identity_file)]
+    if port is not None:
+        cmd += ["-p", str(port)]
+    cmd.append(destination)
+    if dry_run:
+        out.text(shlex.join(cmd))
+        return
+    out.text(f"Running `{shlex.join(cmd)}`")
+    result = subprocess.run(cmd)
+    raise click.exceptions.Exit(code=result.returncode)
+
+
+### 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 the appropriate registry
+    if library == "huggingface_hub" and installation_method() == "brew":
+        latest_version = _fetch_latest_brew_version()
+    else:
+        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 _fetch_latest_brew_version() -> str | None:
+    """Fetch the latest version of the `hf` formula from the Homebrew registry. Returns None if the request fails."""
+    try:
+        response = get_session().get("https://formulae.brew.sh/api/formula/hf.json", timeout=2)
+        hf_raise_for_status(response)
+        return response.json()["versions"]["stable"]
+    except Exception:
+        logger.debug("Error while fetching latest version from Homebrew.", 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

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/_completion.py

@@ -0,0 +1,105 @@
+# 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.
+"""Shell completion for the ``hf`` CLI, built on Click's native completion.
+
+Click generates completion scripts activated by the ``_HF_COMPLETE`` env var (this
+works out of the box because ``hf`` is a Click command). This module exposes the two
+conveniences Typer used to provide — ``--install-completion`` / ``--show-completion``
+— as thin eager options over that machinery.
+"""
+
+import os
+from pathlib import Path
+from typing import Annotated
+
+import click
+from click.shell_completion import get_completion_class
+
+from ._framework import Option
+
+
+_COMPLETE_VAR = "_HF_COMPLETE"
+
+# Shells with a shared rc file: the line that activates completion (appended once).
+_RC_ACTIVATION: dict[str, tuple[Path, str]] = {
+    "bash": (Path.home() / ".bashrc", f'eval "$({_COMPLETE_VAR}=bash_source hf)"'),
+    "zsh": (Path.home() / ".zshrc", f'eval "$({_COMPLETE_VAR}=zsh_source hf)"'),
+}
+# Fish auto-loads per-command files from its completions directory. The file is dedicated
+# to `hf`, so the full script is written there directly (overwriting any stale version)
+# instead of re-generating it via `hf` on every shell startup.
+_FISH_COMPLETION_PATH = Path.home() / ".config" / "fish" / "completions" / "hf.fish"
+
+
+def _detect_shell() -> str:
+    return Path(os.environ.get("SHELL", "")).name or "bash"
+
+
+def _completion_script(shell: str) -> str:
+    # Imported lazily to avoid a circular import (hf.py imports the options below).
+    from .hf import app
+
+    completion_cls = get_completion_class(shell)
+    if completion_cls is None:
+        raise click.ClickException(f"Shell '{shell}' is not supported for completion.")
+    return completion_cls(app, {}, "hf", _COMPLETE_VAR).source()
+
+
+def _show_completion(value: bool) -> None:
+    if not value:
+        return
+    click.echo(_completion_script(_detect_shell()))
+    raise click.exceptions.Exit()
+
+
+def _install_completion(value: bool) -> None:
+    if not value:
+        return
+    shell = _detect_shell()
+    if shell == "fish":
+        path = _FISH_COMPLETION_PATH
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(_completion_script("fish"))
+    elif shell in _RC_ACTIVATION:
+        path, activation = _RC_ACTIVATION[shell]
+        path.parent.mkdir(parents=True, exist_ok=True)
+        existing = path.read_text() if path.exists() else ""
+        if activation not in existing:
+            with path.open("a") as file:
+                file.write(f"\n{activation}\n")
+    else:
+        raise click.ClickException(f"Shell '{shell}' is not supported for completion.")
+    click.echo(f"{shell} completion installed in {path}. Restart your shell for it to take effect.")
+    raise click.exceptions.Exit()
+
+
+InstallCompletionOpt = Annotated[
+    bool,
+    Option(
+        "--install-completion",
+        callback=_install_completion,
+        is_eager=True,
+        help="Install completion for the current shell.",
+    ),
+]
+
+ShowCompletionOpt = Annotated[
+    bool,
+    Option(
+        "--show-completion",
+        callback=_show_completion,
+        is_eager=True,
+        help="Show completion for the current shell, to copy it or customize the installation.",
+    ),
+]

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/_cp.py

@@ -0,0 +1,253 @@
+# 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 ``cp`` command to copy files between local paths, repositories and buckets.
+
+This single command backs three identical CLI entry points: ``hf cp`` (top-level),
+``hf repos cp`` and ``hf buckets cp``. It supports any source/destination combination
+of local file, repo/bucket ``hf://`` URI, and ``-`` (stdin/stdout), with two exceptions:
+- bucket-to-repo copies are not supported (server limitation), and
+- local-to-local copies (use a regular ``cp`` for that).
+"""
+
+import os
+import sys
+from dataclasses import replace
+from typing import Annotated, Literal
+
+import click
+
+from huggingface_hub import HfApi
+from huggingface_hub.errors import CLIError
+from huggingface_hub.utils import HfUri, SoftTemporaryDirectory, disable_progress_bars, is_hf_uri, parse_hf_uri
+
+from ._cli_utils import TokenOpt, get_hf_api
+from ._framework import Argument
+from ._output import out
+
+
+CP_EXAMPLES = [
+    # Download (repo or bucket -> local / stdout)
+    "hf cp hf://username/my-model/config.json",
+    "hf cp hf://username/my-model/config.json ./config.json",
+    "hf cp hf://datasets/username/my-dataset/data.csv ./data/",
+    "hf cp hf://buckets/username/my-bucket/config.json -",
+    # Upload (local / stdin -> repo or bucket)
+    "hf cp ./model.safetensors hf://username/my-model/model.safetensors",
+    "hf cp ./config.json hf://buckets/username/my-bucket/logs/",
+    "hf cp - hf://buckets/username/my-bucket/config.json",
+    # Remote to remote (repo/bucket -> repo/bucket, server-side when possible)
+    "hf cp hf://username/source-model/ hf://username/dest-model/",
+    "hf cp hf://datasets/username/my-dataset/processed/ hf://buckets/username/my-bucket/processed/",
+    "hf cp hf://buckets/username/my-bucket/logs/ hf://buckets/username/archive-bucket/  # copies contents only",
+]
+
+
+# Which alias registered the command, used to restrict the remote endpoint type (see `_enforce_context`).
+CpContext = Literal["repos", "buckets"]
+
+
+def make_cp(context: CpContext | None = None):
+    """Build the ``cp`` command function for a given alias.
+
+    The three entry points (`hf cp`, `hf repos cp`, `hf buckets cp`) share the exact same logic;
+    'context' only adds a guardrail on the remote endpoint type (see `_enforce_context`).
+    """
+
+    def cp(
+        src: Annotated[
+            str,
+            Argument(help="Source: local file, hf:// URI (repo or bucket), or - for stdin."),
+        ],
+        dst: Annotated[
+            str | None,
+            Argument(help="Destination: local path, hf:// URI (repo or bucket), or - for stdout."),
+        ] = None,
+        token: TokenOpt = None,
+    ) -> None:
+        """Copy files between local paths, repositories, and buckets.
+
+        Handles uploads (local/stdin -> repo/bucket), downloads (repo/bucket -> local/stdout) and
+        remote-to-remote copies (repo/bucket -> repo/bucket). Bucket-to-repo and local-to-local
+        copies are not supported. For directories, use `hf upload`/`hf download` (repos) or
+        `hf buckets sync` (buckets). Remote-to-remote copies only work within the same storage
+        region (https://huggingface.co/docs/hub/storage-regions).
+        """
+        _enforce_context(context, src, dst)
+        _run_cp(src, dst, token)
+
+    return cp
+
+
+def _enforce_context(context: CpContext | None, src: str, dst: str | None) -> None:
+    """Guardrail for the `hf repos cp` / `hf buckets cp` aliases.
+
+    These aliases are exact duplicates of `hf cp`, so a bare `hf repos cp` could otherwise touch a
+    bucket (and vice versa). We validate the type of the remote side: the destination for uploads and
+    remote-to-remote copies, or the source when downloading to a local path / stdout. The top-level
+    `hf cp` (i.e. 'context' is None) accepts any combination.
+    """
+    if context is None:
+        return
+    # The remote endpoint is the destination when it is an hf:// URI, otherwise the source (download).
+    remote = dst if (dst is not None and is_hf_uri(dst)) else src
+    if not is_hf_uri(remote):
+        return
+    if context == "repos" and parse_hf_uri(remote).is_bucket:
+        raise CLIError("`hf repos cp` only works with repositories. Use `hf cp` or `hf buckets cp` for buckets.")
+    if context == "buckets" and not parse_hf_uri(remote).is_bucket:
+        raise CLIError("`hf buckets cp` only works with buckets. Use `hf cp` or `hf repos cp` for repositories.")
+
+
+def _run_cp(src: str, dst: str | None, token: str | None) -> None:
+    api = get_hf_api(token=token)
+
+    src_is_stdin = src == "-"
+    dst_is_stdout = dst == "-"
+    src_is_hf = is_hf_uri(src)
+    dst_is_hf = dst is not None and is_hf_uri(dst)
+
+    # --- Remote to remote: delegate to copy_files (repo/bucket -> repo/bucket) ---
+    if src_is_hf and dst_is_hf:
+        assert dst is not None  # guaranteed by dst_is_hf
+        api.copy_files(src, dst)
+        out.result("Copied", src=src, dst=dst)
+        return
+
+    # --- At least one side must be a remote hf:// URI (rules out local->local, stdin->local, etc.) ---
+    if not src_is_hf and not dst_is_hf:
+        if dst is None:
+            raise click.BadParameter("Missing destination. Provide a repo or bucket hf:// URI as DST.")
+        raise click.BadParameter(
+            "One of SRC or DST must be a repo (hf://username/...) or bucket (hf://buckets/...) URI."
+        )
+
+    # --- Download: repo/bucket -> local file or stdout ---
+    if src_is_hf:
+        if dst_is_stdout:
+            _download_file_to_stdout(api, src)
+            return
+        _download_file_to_local(api, src, dst)
+        return
+
+    # --- Upload: local file or stdin -> repo/bucket ---
+    assert dst is not None  # guaranteed: reaching here means dst_is_hf is True
+    _upload_file_to_remote(api, src, dst, src_is_stdin=src_is_stdin)
+
+
+def _download_file_to_stdout(api: HfApi, src: str) -> None:
+    uri = parse_hf_uri(src)
+    filename = _source_filename(uri, src)
+    # Suppress progress bars to avoid polluting the piped output.
+    with disable_progress_bars():
+        with SoftTemporaryDirectory() as tmp_dir:
+            tmp_path = os.path.join(tmp_dir, filename)
+            _download_single(api, uri, tmp_path)
+            with open(tmp_path, "rb") as f:
+                while chunk := f.read(32_000_000):  # 32MB chunks
+                    sys.stdout.buffer.write(chunk)
+
+
+def _download_file_to_local(api: HfApi, src: str, dst: str | None) -> None:
+    uri = parse_hf_uri(src)
+    filename = _source_filename(uri, src)
+
+    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
+
+    parent_dir = os.path.dirname(local_path)
+    if parent_dir:
+        os.makedirs(parent_dir, exist_ok=True)
+
+    _download_single(api, uri, local_path)
+    out.result("Downloaded", src=src, dst=local_path)
+
+
+def _download_single(api: HfApi, uri: HfUri, local_path: str) -> None:
+    """Download a single file (repo or bucket) to ``local_path``.
+
+    Used by `_download_file_to_local` and `_download_file_to_stdout`.
+    """
+    if uri.is_bucket:
+        api.download_bucket_files(uri.id, [(uri.path_in_repo, local_path)], raise_on_missing_files=True)
+    else:
+        # Download into a temporary folder next to the destination (rather than the shared cache)
+        # so the final move stays on the same filesystem and is instant. The temp folder is
+        # cleaned up automatically once the move is complete.
+        parent_dir = os.path.dirname(local_path) or "."
+        with SoftTemporaryDirectory(prefix=".tmp", dir=parent_dir) as tmp_dir:
+            downloaded_path = api.hf_hub_download(
+                repo_id=uri.id,
+                repo_type=uri.type,
+                filename=uri.path_in_repo,
+                revision=uri.revision,
+                local_dir=tmp_dir,
+            )
+            os.replace(downloaded_path, local_path)
+
+
+def _source_filename(uri: HfUri, src: str) -> str:
+    if uri.path_in_repo == "" or src.endswith("/"):
+        raise click.BadParameter(
+            "Source path must include a file name, not just a repo/bucket or directory path."
+            " Use `hf download` or `hf buckets sync` to copy directories."
+        )
+    return uri.path_in_repo.rsplit("/", 1)[-1]
+
+
+def _upload_file_to_remote(api: HfApi, src: str, dst: str, *, src_is_stdin: bool) -> None:
+    uri = parse_hf_uri(dst)
+
+    if src_is_stdin:
+        if uri.path_in_repo == "" or dst.endswith("/"):
+            raise click.BadParameter("Stdin upload requires a full destination path including filename.")
+        data = sys.stdin.buffer.read()
+        _upload_single(api, uri, data, uri.path_in_repo)
+        out.result("Uploaded", src="stdin", dst=uri.to_uri())
+        return
+
+    if os.path.isdir(src):
+        raise click.BadParameter(
+            "Source must be a file, not a directory. Use `hf upload` or `hf buckets sync` for directories."
+        )
+    if not os.path.isfile(src):
+        raise click.BadParameter(f"Source file not found: {src}")
+
+    prefix = uri.path_in_repo
+    if prefix == "":
+        remote_path = os.path.basename(src)
+    elif dst.endswith("/"):
+        remote_path = prefix + "/" + os.path.basename(src)
+    else:
+        remote_path = prefix
+
+    _upload_single(api, uri, src, remote_path)
+    out.result("Uploaded", src=src, dst=replace(uri, path_in_repo=remote_path).to_uri())
+
+
+def _upload_single(api: HfApi, uri: HfUri, source: str | bytes, remote_path: str) -> None:
+    """Upload a single file or bytes (to a repo or bucket)."""
+    if uri.is_bucket:
+        api.batch_bucket_files(uri.id, add=[(source, remote_path)])
+    else:
+        api.upload_file(
+            path_or_fileobj=source,
+            path_in_repo=remote_path,
+            repo_id=uri.id,
+            repo_type=uri.type,
+            revision=uri.revision,
+        )

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/_errors.py

@@ -0,0 +1,155 @@
+# 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,
+    DeviceCodeError,
+    EntryNotFoundError,
+    GatedRepoError,
+    HfHubHTTPError,
+    HfUriError,
+    IncompleteSnapshotError,
+    LocalEntryNotFoundError,
+    LocalTokenNotFoundError,
+    OfflineModeIsEnabled,
+    OIDCError,
+    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 += "\nIf the repo is private, make sure you are authenticated and your token has the required permissions."
+
+    msg += "\nIf the repo does not exist, create it with: "
+    if error.repo_id is not None:
+        type_flag = f" --type {error.repo_type}" if error.repo_type and error.repo_type != "model" else ""
+        msg += f"hf repos create {error.repo_id}{type_flag}"
+    else:
+        msg += "hf repos create <repo_id>"
+
+    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:
+        msg = f"Bucket '{error.bucket_id}' not found."
+        cmd = f"hf buckets create {error.bucket_id}"
+    else:
+        msg = "Bucket not found."
+        cmd = "hf buckets create <bucket_id>"
+    msg += "\nIf the bucket is private, make sure you are authenticated and your token has the required permissions."
+    msg += f"\nIf the bucket does not exist, create it with: {cmd}"
+    return msg
+
+
+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_local_entry_not_found(error: LocalEntryNotFoundError) -> str:
+    cause = error.__cause__
+    if cause is not None:
+        return f"Local entry not found. {cause}"
+    return f"Local entry not found. {error}"
+
+
+def _format_incomplete_snapshot(error: IncompleteSnapshotError) -> str:
+    msg = _format_local_entry_not_found(error)
+    msg += f"\nIncomplete snapshot available at: {error.snapshot_path}"
+    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]] = {
+    OfflineModeIsEnabled: lambda error: str(error),
+    # 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.",
+    OIDCError: lambda error: f"OIDC Exchange failed. {error}",
+    DeviceCodeError: lambda error: f"Login failed: {error}",
+    RemoteEntryNotFoundError: _format_entry_not_found,
+    # IncompleteSnapshotError must come before LocalEntryNotFoundError (it's a subclass).
+    IncompleteSnapshotError: _format_incomplete_snapshot,
+    LocalEntryNotFoundError: _format_local_entry_not_found,
+    EntryNotFoundError: lambda error: str(error),
+    HfHubHTTPError: lambda error: str(error),
+    HfUriError: lambda error: f"Invalid HF URI: {error.uri}. {error.msg}",
+    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

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/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 click
+
+from huggingface_hub._buckets import BucketFile, BucketFolder
+from huggingface_hub.hf_api import RepoFile, RepoFolder
+
+from ._cli_utils import get_hf_api
+from ._output import OutputFormat, _dataclass_to_dict, 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 == OutputFormat.json:
+        raise click.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 == OutputFormat.quiet
+        for line in build_tree(items, human_readable=human_readable, quiet=quiet):
+            print(line)
+    elif out.mode == OutputFormat.json:
+        print(json.dumps([_dataclass_to_dict(item) for item in items], indent=2))
+    elif out.mode == OutputFormat.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.")

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/_framework.py

@@ -0,0 +1,645 @@
+# 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.
+"""Minimal declaration layer over Click 8.x for the ``hf`` CLI.
+
+This module vendors *only* the slice of Typer the CLI actually uses: turning
+annotated function signatures (``Annotated[T, Option(...)]`` / ``Argument(...)``)
+into Click parameters, and rendering argument/option help the way Typer did.
+It exists so the CLI depends on Click's stable public API instead of Typer's
+now-internal vendored Click (``typer._click``), which Typer reserves the right
+to refactor at any release.
+
+Deliberately *not* implemented (add a case here only when a command needs it):
+rich rendering, shell-completion install commands, prompts/confirmation options,
+env-var options, ``File``/``UUID`` params, ``count`` options, ``default_factory``.
+Click's own machinery already handles exceptions, aborts, exits, and native
+``_HF_COMPLETE`` shell completion, so none of Typer's ``main()`` overrides are
+reproduced here.
+
+The interesting logic mirrors four Typer functions, kept faithful so ``--help``
+output stays byte-identical:
+- :func:`_get_click_type`          <- ``typer.main.get_click_type``
+- :func:`_build_click_param`       <- ``typer.main.get_click_param``
+- :func:`_make_handler`            <- ``typer.main.get_callback``
+- :class:`HfArgument` / :class:`HfOption` help records <- ``typer.core.Typer*``
+"""
+
+import enum
+import functools
+import inspect
+from collections.abc import Callable, Sequence
+from datetime import datetime
+from pathlib import Path
+from types import UnionType
+from typing import Annotated, Any, Literal, Union, get_args, get_origin
+
+import click
+
+
+def get_command_name(name: str) -> str:
+    """Normalize a Python identifier to a CLI name (``force_download`` -> ``force-download``)."""
+    return name.lower().replace("_", "-")
+
+
+# ---------------------------------------------------------------------------
+# 1. Declaration markers — replace ``typer.Option`` / ``typer.Argument``.
+#    Attached in ``Annotated[T, Option(...)]``; the ``= value`` in the function
+#    signature carries the default (never the marker).
+# ---------------------------------------------------------------------------
+
+
+class ParameterInfo:
+    """Base marker holding the (tiny) set of Click knobs the CLI actually sets.
+
+    ``callback`` is a Typer-style value parser ``fn(value) -> parsed`` — it does NOT
+    receive Click's ``(ctx, param, value)``. It consumes the enum/list convertors, so
+    ``value`` is already converted when it runs.
+    """
+
+    def __init__(
+        self,
+        *param_decls: str,
+        help: str | None = None,
+        show_default: bool | str = True,
+        hidden: bool = False,
+        is_eager: bool = False,
+        callback: Callable[..., Any] | None = None,
+        min: int | None = None,
+        click_type: click.ParamType | None = None,
+    ) -> None:
+        self.param_decls = list(param_decls)
+        self.help = help
+        self.show_default = show_default
+        self.hidden = hidden
+        self.is_eager = is_eager
+        self.callback = callback
+        self.min = min
+        self.click_type = click_type
+
+
+class Option(ParameterInfo):
+    """Declare a CLI option, e.g. ``Annotated[str | None, Option("--revision")]``."""
+
+
+class Argument(ParameterInfo):
+    """Declare a positional CLI argument, e.g. ``Annotated[str, Argument()]``."""
+
+
+# ---------------------------------------------------------------------------
+# 2. Annotation -> Click type + value convertors.
+# ---------------------------------------------------------------------------
+
+
+def _get_click_type(annotation: Any, info: ParameterInfo) -> click.ParamType:
+    """Map a (already unwrapped) annotation to a Click ``ParamType``."""
+    if info.click_type is not None:
+        return info.click_type
+    if annotation is str:
+        return click.STRING
+    if annotation is bool:
+        return click.BOOL
+    if annotation is int:
+        return click.IntRange(min=info.min) if info.min is not None else click.INT
+    if annotation is float:
+        return click.FloatRange(min=info.min) if info.min is not None else click.FLOAT
+    if annotation is Path:
+        return click.Path(path_type=Path)
+    if annotation is datetime:
+        return click.DateTime()
+    if isinstance(annotation, type) and issubclass(annotation, enum.Enum):
+        values = [item.value for item in annotation]
+        if not all(isinstance(value, str) for value in values):
+            # A non-str member default would fail Choice validation at parse time with a
+            # cryptic error; fail at build time with a clear one instead.
+            raise TypeError(f"Unsupported enum {annotation.__name__!r}: only str-valued enums are supported.")
+        return click.Choice(values)
+    if get_origin(annotation) is Literal:
+        return click.Choice([str(value) for value in get_args(annotation)])
+    raise TypeError(f"Unsupported CLI annotation {annotation!r}. Add a case in `_framework._get_click_type()`.")
+
+
+def _enum_convertor(enum_type: type[enum.Enum]) -> Callable[[Any], Any]:
+    """Map a parsed choice string back to its ``Enum`` member (mirrors Typer)."""
+    value_map = {str(member.value): member for member in enum_type}
+
+    def convertor(value: Any) -> Any:
+        if value is not None:
+            return value_map.get(str(value))
+        return None
+
+    return convertor
+
+
+def _list_convertor(
+    inner: Callable[[Any], Any] | None, default_value: Any | None
+) -> Callable[[Sequence[Any] | None], list[Any] | None]:
+    """Turn Click's tuple (from ``multiple=True``) into a list, applying ``inner`` per item."""
+
+    def convertor(value: Sequence[Any] | None) -> list[Any] | None:
+        if value is None or (default_value is None and len(value) == 0):
+            return None
+        return [inner(item) if inner else item for item in value]
+
+    return convertor
+
+
+def _make_convertor(
+    annotation: Any, is_list: bool, default_value: Any | None, info: ParameterInfo
+) -> Callable[[Any], Any] | None:
+    """Build the value convertor for a param (``None`` when no coercion is needed).
+
+    An explicit ``click_type`` (e.g. ``SoftChoice``) owns its own conversion, so no
+    enum convertor is added on top of it.
+    """
+    inner = None
+    if info.click_type is None and isinstance(annotation, type) and issubclass(annotation, enum.Enum):
+        inner = _enum_convertor(annotation)
+    if is_list:
+        return _list_convertor(inner, default_value)
+    return inner
+
+
+def _unwrap_optional_and_list(annotation: Any) -> tuple[Any, bool]:
+    """Strip ``T | None`` / ``Optional[T]`` and ``list[T]``; return ``(base_type, is_list)``."""
+    origin = get_origin(annotation)
+    if origin in (Union, UnionType):
+        non_none = [arg for arg in get_args(annotation) if arg is not type(None)]
+        if len(non_none) != 1:
+            raise TypeError(f"Unsupported union annotation {annotation!r}; only ``T | None`` is supported.")
+        annotation = non_none[0]
+        origin = get_origin(annotation)
+    if origin in (list, Sequence):
+        return get_args(annotation)[0], True
+    return annotation, False
+
+
+def _split_annotated(annotation: Any) -> tuple[Any, ParameterInfo | None]:
+    """Split ``Annotated[T, Option(...)]`` into ``(T, marker)``; ``(annotation, None)`` otherwise."""
+    if get_origin(annotation) is Annotated:
+        args = get_args(annotation)
+        marker = next((meta for meta in args[1:] if isinstance(meta, ParameterInfo)), None)
+        if marker is None and (typer_marker := next((meta for meta in args[1:] if _is_typer_marker(meta)), None)):
+            marker = _from_typer_marker(typer_marker, from_annotated=True)
+        return args[0], marker
+    return annotation, None
+
+
+# ---------------------------------------------------------------------------
+# Typer-marker compatibility shim (transition helper).
+#
+# ``typer_factory`` is exposed publicly and downstream CLIs (e.g. `transformers`)
+# still register commands whose parameters carry ``typer.Option`` /
+# ``typer.Argument`` markers. Recognize those markers structurally (no typer
+# import required) and translate the fields this framework supports, so such
+# commands keep working while downstream migrates.
+# TODO: remove once transformers pins huggingface_hub>=1.22.0.
+# ---------------------------------------------------------------------------
+
+
+def _is_typer_marker(obj: Any) -> bool:
+    return type(obj).__module__.partition(".")[0] == "typer" and type(obj).__name__ in ("OptionInfo", "ArgumentInfo")
+
+
+def _from_typer_marker(meta: Any, *, from_annotated: bool) -> ParameterInfo:
+    """Translate a ``typer.models.OptionInfo`` / ``ArgumentInfo`` into our marker."""
+    param_decls = list(getattr(meta, "param_decls", None) or ())
+    if type(meta).__name__ == "OptionInfo":
+        # In ``Annotated[...]`` usage typer stores the first flag name in ``default``
+        # (``Option("--flag", "-f")`` -> ``default="--flag"``, ``param_decls=("-f",)``).
+        default = getattr(meta, "default", ...)
+        if from_annotated and isinstance(default, str):
+            param_decls = [default, *param_decls]
+        cls: type[ParameterInfo] = Option
+    else:
+        cls = Argument
+    return cls(
+        *param_decls,
+        help=getattr(meta, "help", None),
+        show_default=getattr(meta, "show_default", True),
+        hidden=getattr(meta, "hidden", False),
+        is_eager=getattr(meta, "is_eager", False),
+        callback=getattr(meta, "callback", None),
+        min=getattr(meta, "min", None),
+        click_type=getattr(meta, "click_type", None),
+    )
+
+
+# ---------------------------------------------------------------------------
+# 3. Signature -> Click parameters (mirrors ``typer.main.get_click_param``).
+# ---------------------------------------------------------------------------
+
+
+def _wrap_param_callback(
+    user_callback: Callable[[Any], Any], convertor: Callable[[Any], Any] | None
+) -> Callable[[click.Context, click.Parameter, Any], Any]:
+    """Adapt a Typer-style value parser ``fn(value) -> parsed`` to a Click param callback."""
+
+    def click_callback(ctx: click.Context, param: click.Parameter, value: Any) -> Any:
+        return user_callback(convertor(value) if convertor else value)
+
+    return click_callback
+
+
+def _build_click_param(
+    name: str, annotation: Any, info: ParameterInfo | None, signature_default: Any
+) -> tuple[click.Parameter, Callable[[Any], Any] | None]:
+    """Build a Click ``Parameter`` (and its post-parse value convertor) for one function param."""
+    required = signature_default is inspect.Parameter.empty
+    default_value = None if required else signature_default
+    if isinstance(default_value, enum.Enum):
+        default_value = default_value.value
+    if info is None:
+        # A bare annotation with no marker: required positional -> Argument, else Option.
+        info = Argument() if required else Option()
+
+    base_type, is_list = _unwrap_optional_and_list(annotation)
+    convertor = _make_convertor(base_type, is_list, default_value, info)
+
+    # A user ``callback`` consumes the value itself (and the convertor with it); otherwise the
+    # convertor runs later in the command handler wrapper. This keeps conversion single-pass.
+    if info.callback is not None:
+        param_callback: Callable[..., Any] | None = _wrap_param_callback(info.callback, convertor)
+        handler_convertor: Callable[[Any], Any] | None = None
+    else:
+        param_callback = None
+        handler_convertor = convertor
+
+    if isinstance(info, Argument):
+        argument = HfArgument(
+            [name],
+            type=_get_click_type(base_type, info),
+            required=required,
+            default=default_value,
+            nargs=-1 if is_list else 1,
+            is_eager=info.is_eager,
+            callback=param_callback,
+            help=info.help,
+            show_default=info.show_default,
+            hidden=info.hidden,
+        )
+        return argument, handler_convertor
+
+    # Option: prepend the Python name so ``click.Parameter.name`` matches the function kwarg,
+    # regardless of the user-facing flag names ("-v"/"--version", "--type"/"--repo-type", ...).
+    is_flag = base_type is bool
+    decls = [name]
+    if info.param_decls:
+        decls.extend(info.param_decls)
+    else:
+        kebab = get_command_name(name)
+        decls.append(f"--{kebab}/--no-{kebab}" if is_flag else f"--{kebab}")
+    option = HfOption(
+        decls,
+        # Click infers the flag type itself; passing a type alongside ``is_flag`` is rejected.
+        type=None if is_flag else _get_click_type(base_type, info),
+        required=required,
+        default=default_value,
+        is_flag=is_flag,
+        multiple=is_list,
+        is_eager=info.is_eager,
+        callback=param_callback,
+        help=info.help,
+        show_default=info.show_default,
+        hidden=info.hidden,
+    )
+    return option, handler_convertor
+
+
+def _build_params(
+    func: Callable[..., Any],
+) -> tuple[list[click.Parameter], dict[str, Callable[[Any], Any]], str | None]:
+    """Introspect ``func`` and return ``(params, convertors, context_param_name)``."""
+    params: list[click.Parameter] = []
+    convertors: dict[str, Callable[[Any], Any]] = {}
+    context_param_name: str | None = None
+    for name, sig_param in inspect.signature(func).parameters.items():
+        # Read raw signature annotations rather than ``typing.get_type_hints``: the CLI never uses
+        # ``from __future__ import annotations``, so annotations are already live objects, and
+        # get_type_hints mangles ``Annotated[X | None, ...]`` on Python 3.10 (drops the origin).
+        annotation = sig_param.annotation if sig_param.annotation is not inspect.Parameter.empty else str
+        base_type, info = _split_annotated(annotation)
+        if isinstance(base_type, type) and (
+            issubclass(base_type, click.Context)
+            # typer.Context subclasses typer's *vendored* click since typer 0.26, so an
+            # issubclass check against real click misses it. Match it structurally.
+            or (base_type.__module__.partition(".")[0] == "typer" and base_type.__name__ == "Context")
+        ):
+            context_param_name = name
+            continue
+        signature_default = sig_param.default
+        if _is_typer_marker(signature_default):
+            # Old typer style: the marker *is* the signature default and carries the value.
+            if info is None:
+                info = _from_typer_marker(signature_default, from_annotated=False)
+            marker_default = getattr(signature_default, "default", ...)
+            signature_default = inspect.Parameter.empty if marker_default is ... else marker_default
+        click_param, convertor = _build_click_param(name, base_type, info, signature_default)
+        if convertor is not None and click_param.name is not None:
+            convertors[click_param.name] = convertor
+        params.append(click_param)
+    return params, convertors, context_param_name
+
+
+def _make_handler(
+    func: Callable[..., Any],
+    convertors: dict[str, Callable[[Any], Any]],
+    context_param_name: str | None,
+) -> Callable[..., Any]:
+    """Wrap ``func`` so Click's kwargs map back to it, applying convertors and injecting the ctx."""
+
+    def handler(**kwargs: Any) -> Any:
+        call_kwargs = {key: (convertors[key](value) if key in convertors else value) for key, value in kwargs.items()}
+        if context_param_name is not None:
+            call_kwargs[context_param_name] = click.get_current_context()
+        return func(**call_kwargs)
+
+    functools.update_wrapper(handler, func)
+    return handler
+
+
+# ---------------------------------------------------------------------------
+# 4. Click parameter subclasses — port Typer's help records so arguments show up
+#    in ``--help`` (plain ``click.Argument`` renders none) and defaults/metavars
+#    read identically. Rich/env-var branches are dropped (never enabled here).
+# ---------------------------------------------------------------------------
+
+
+def _split_opt(opt: str) -> tuple[str, str]:
+    """Split an option string into ``(prefix, name)`` (Click's ``split_opt``, inlined)."""
+    first = opt[:1]
+    if first.isalnum():
+        return "", opt
+    if opt[1:2] == first:
+        return opt[:2], opt[2:]
+    return first, opt[1:]
+
+
+def _extract_default_help_str(param: click.Parameter, ctx: click.Context) -> Any:
+    # Resilient parsing avoids type casting failing while rendering the default.
+    resilient = ctx.resilient_parsing
+    ctx.resilient_parsing = True
+    try:
+        return param.get_default(ctx, call=False)
+    finally:
+        ctx.resilient_parsing = resilient
+
+
+def _default_string(
+    param: "HfArgument | HfOption", ctx: click.Context, show_default_is_str: bool, default_value: Any
+) -> str:
+    if show_default_is_str:
+        return f"({param.show_default})"
+    if isinstance(default_value, (list, tuple)):
+        return ", ".join(_default_string(param, ctx, show_default_is_str, item) for item in default_value)
+    if isinstance(default_value, enum.Enum):
+        return str(default_value.value)
+    if inspect.isfunction(default_value):
+        return "(dynamic)"
+    if isinstance(param, HfOption) and param.is_bool_flag and param.secondary_opts:
+        # Boolean toggle: show the opt name (without prefix) matching the current default.
+        if default_value:
+            return _split_opt(param.opts[0])[1] if param.opts else str(default_value)
+        return _split_opt(param.secondary_opts[0])[1]
+    if isinstance(param, HfOption) and param.is_bool_flag and not param.secondary_opts and not default_value:
+        return ""
+    return str(default_value)
+
+
+def _describe_number_range(param_type: "click.IntRange | click.FloatRange") -> str:
+    """Human-readable range hint like ``x>=1`` or ``1<=x<10``.
+
+    Reproduces click's private ``_NumberRangeBase._describe_range()`` using the public
+    ``IntRange``/``FloatRange`` attributes, so the framework stays on Click's public API.
+    """
+    if param_type.min is None:
+        return f"x{'<' if param_type.max_open else '<='}{param_type.max}"
+    if param_type.max is None:
+        return f"x{'>' if param_type.min_open else '>='}{param_type.min}"
+    left = "<" if param_type.min_open else "<="
+    right = "<" if param_type.max_open else "<="
+    return f"{param_type.min}{left}x{right}{param_type.max}"
+
+
+def _build_help_extra(param: "HfArgument | HfOption", ctx: click.Context, base_help: str) -> str:
+    """Append the ``[default: ...; required]`` suffix to a help string (shared by arg/option)."""
+    extra: list[str] = []
+    default_value = _extract_default_help_str(param, ctx)
+    show_default_is_str = isinstance(param.show_default, str)
+    if show_default_is_str or (default_value is not None and (param.show_default or ctx.show_default)):
+        default_string = _default_string(param, ctx, show_default_is_str, default_value)
+        if default_string:
+            extra.append(f"default: {default_string}")
+    # Numeric range hints are shown for options only (matches Typer; arguments omit them).
+    if isinstance(param, HfOption) and isinstance(param.type, (click.IntRange, click.FloatRange)):
+        range_str = _describe_number_range(param.type)
+        if range_str:
+            extra.append(range_str)
+    if param.required:
+        extra.append("required")
+    if extra:
+        suffix = f"[{'; '.join(extra)}]"
+        return f"{base_help}  {suffix}" if base_help else suffix
+    return base_help
+
+
+class HfArgument(click.Argument):
+    """Positional argument that renders help text and a metavar (Click's does neither)."""
+
+    def __init__(
+        self,
+        param_decls: Sequence[str],
+        *,
+        help: str | None = None,
+        show_default: bool | str = True,
+        hidden: bool = False,
+        **attrs: Any,
+    ) -> None:
+        self.help = help
+        self.show_default = show_default
+        self.hidden = hidden
+        super().__init__(param_decls, **attrs)
+
+    def make_metavar(self, ctx: click.Context) -> str:
+        if self.metavar is not None:
+            var = self.metavar
+            if not self.required and not var.startswith("["):
+                var = f"[{var}]"
+            return var
+        var = (self.name or "").upper()
+        if not self.required:
+            var = f"[{var}]"
+        type_var = self.type.get_metavar(self, ctx=ctx)
+        if type_var:
+            var += f":{type_var}"
+        if self.nargs != 1:
+            var += "..."
+        return var
+
+    def get_help_record(self, ctx: click.Context) -> tuple[str, str] | None:
+        if self.hidden:
+            return None
+        return self.make_metavar(ctx=ctx), _build_help_extra(self, ctx, self.help or "")
+
+
+class HfOption(click.Option):
+    """Option whose help record ports Typer's default/metavar rendering verbatim."""
+
+    show_default: bool | str
+
+    def get_help_record(self, ctx: click.Context) -> tuple[str, str] | None:
+        if self.hidden:
+            return None
+
+        any_prefix_is_slash = False
+
+        def _write_opts(opts: Sequence[str]) -> str:
+            nonlocal any_prefix_is_slash
+            rv, any_slashes = click.formatting.join_options(opts)
+            if any_slashes:
+                any_prefix_is_slash = True
+            if not self.is_flag and not self.count:
+                rv += f" {self.make_metavar(ctx=ctx)}"
+            return rv
+
+        rv = [_write_opts(self.opts)]
+        if self.secondary_opts:
+            rv.append(_write_opts(self.secondary_opts))
+
+        help_text = _build_help_extra(self, ctx, self.help or "")
+        return ("; " if any_prefix_is_slash else " / ").join(rv), help_text
+
+
+# ---------------------------------------------------------------------------
+# 5. Command / group base classes and the decorator API (replace ``typer.Typer``).
+# ---------------------------------------------------------------------------
+
+
+def _format_params(command: click.Command, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+    """Render params split into "Arguments" and "Options" sections (mirrors Typer)."""
+    args: list[tuple[str, str]] = []
+    opts: list[tuple[str, str]] = []
+    for param in command.get_params(ctx):
+        record = param.get_help_record(ctx)
+        if record is None:
+            continue
+        if param.param_type_name == "argument":
+            args.append(record)
+        elif param.param_type_name == "option":
+            opts.append(record)
+    if args:
+        with formatter.section("Arguments"):
+            formatter.write_dl(args)
+    if opts:
+        with formatter.section("Options"):
+            formatter.write_dl(opts)
+
+
+class HfCommand(click.Command):
+    """Leaf command that renders arguments and options in separate help sections."""
+
+    def format_options(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        _format_params(self, ctx, formatter)
+
+
+def build_command(
+    func: Callable[..., Any],
+    *,
+    name: str | None = None,
+    cls: type[click.Command] | 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,
+    context_settings: dict[str, Any] | None = None,
+) -> click.Command:
+    """Build a Click ``Command`` from a function with ``Annotated`` params.
+
+    Replaces ``typer.main.get_command_from_info``.
+    """
+    params, convertors, context_param_name = _build_params(func)
+    handler = _make_handler(func, convertors, context_param_name)
+    command_help = inspect.cleandoc(help) if help else inspect.getdoc(func)
+    return (cls or HfCommand)(
+        name=name if name is not None else get_command_name(func.__name__),
+        callback=handler,
+        params=params,
+        help=command_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,
+        context_settings=context_settings or {},
+    )
+
+
+class HfGroup(click.Group):
+    """Command group with the decorator API the CLI relies on (``command``/``callback``/``add_group``).
+
+    Subclasses (see ``HFCliTyperGroup``) layer on styling, aliases, topics and error
+    enrichment; this base only wires functions to Click via :func:`build_command`.
+    """
+
+    #: Command class used by ``@group.command()`` unless overridden per call.
+    command_class: type[click.Command] = HfCommand
+
+    def format_options(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        _format_params(self, ctx, formatter)
+        self.format_commands(ctx, formatter)
+
+    def list_commands(self, ctx: click.Context) -> list[str]:
+        # Preserve declaration order rather than Click's alphabetical default.
+        return list(self.commands)
+
+    def command(  # type: ignore  # deliberately narrows click.Group.command (builds from annotated signatures)
+        self, name: str | None = None, *, cls: type[click.Command] | None = None, **kwargs: Any
+    ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+        def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+            command = build_command(func, name=name, cls=cls or self.command_class, **kwargs)
+            self.add_command(command, command.name)
+            return func
+
+        return decorator
+
+    def add_group(self, group: click.Group, *, name: str, hidden: bool = False) -> None:
+        """Register a subgroup under ``name`` (which may carry pipe aliases, e.g. ``"repos | repo"``)."""
+        group.name = name
+        group.hidden = hidden
+        self.add_command(group, name)
+
+    def group_callback(
+        self, *, invoke_without_command: bool = False
+    ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+        """Register the function invoked for this group (named ``group_callback`` because Click
+        already uses the ``callback`` attribute for the group's own handler)."""
+
+        def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+            params, convertors, context_param_name = _build_params(func)
+            self.callback = _make_handler(func, convertors, context_param_name)
+            self.params = [*self.params, *params]
+            self.invoke_without_command = invoke_without_command
+            if invoke_without_command:
+                # Match Typer: the subcommand is optional when the group runs without one.
+                self.subcommand_metavar = "[COMMAND] [ARGS]..."
+            if self.help is None and func.__doc__:
+                self.help = inspect.cleandoc(func.__doc__)
+            return func
+
+        return decorator

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/_help_formatter.py

@@ -0,0 +1,34 @@
+# 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.
+"""Pretty ANSI help formatter for the `hf` CLI."""
+
+from collections.abc import Iterable
+
+import click
+
+from huggingface_hub.utils import ANSI
+
+
+class StyledHelpFormatter(click.HelpFormatter):
+    def write_heading(self, heading: str) -> None:
+        styled = ANSI.underline(heading + ":")
+        self.write(f"{'':>{self.current_indent}}{styled}\n")
+
+    def write_dl(self, rows: Iterable[tuple[str, str]], col_max: int = 30, col_spacing: int = 2) -> None:
+        rows = [(ANSI.bold(first), second) for first, second in rows]
+        super().write_dl(rows, col_max=col_max, col_spacing=col_spacing)
+
+
+class StyledContext(click.Context):
+    formatter_class = StyledHelpFormatter

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/_output.py

@@ -0,0 +1,360 @@
+# 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 shutil
+import sys
+from collections.abc import Sequence
+from enum import Enum
+from typing import Any, cast
+
+import click
+
+from huggingface_hub.errors import ConfirmationError
+from huggingface_hub.utils import ANSI, StatusLine, disable_progress_bars, is_agent, tabulate
+
+
+class OutputFormat(str, Enum):
+    """Output format for CLI commands with auto detection of agent/human mode."""
+
+    agent = "agent"
+    auto = "auto"
+    human = "human"
+    json = "json"
+    quiet = "quiet"
+
+
+def _print_flush(*values: Any, **kwargs: Any) -> None:
+    """Like `print`, but always flushed: some CLI flows block on user action right after
+    printing (e.g. the device-code login), so output must not stay buffered."""
+    print(*values, **kwargs, flush=True)
+
+
+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: OutputFormat
+    no_truncate: bool
+
+    def __init__(self) -> None:
+        self.no_truncate = False
+        self.set_mode()
+
+    def set_mode(self, mode: OutputFormat = OutputFormat.auto) -> None:
+        """Override the output mode (called once at startup and again per '--format' flag)."""
+        if mode == OutputFormat.auto:
+            mode = OutputFormat.agent if is_agent() else OutputFormat.human
+        self.mode = mode
+        if mode != OutputFormat.human:
+            disable_progress_bars()
+
+    def set_no_truncate(self, no_truncate: bool) -> None:
+        """Toggle off cell truncation for human table output."""
+        self.no_truncate = no_truncate
+
+    def is_quiet(self) -> bool:
+        return self.mode == OutputFormat.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 OutputFormat.human:
+                if human is not None:
+                    _print_flush(human)
+            case OutputFormat.agent:
+                if agent is not None:
+                    _print_flush(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 OutputFormat.agent | OutputFormat.human:
+                    _print_flush("No results found.")
+                case OutputFormat.json:
+                    _print_flush("[]")
+            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 OutputFormat.human:  # padded table, adaptive truncation, SCREAMING_SNAKE headers
+                screaming_headers = [_to_header(h) for h in headers]
+                formatted_rows: list[list[str]] = [[_format_table_value_human(v) for v in row] for row in rows]
+
+                is_truncated = _truncate_columns(screaming_headers, formatted_rows, no_truncate=self.no_truncate)
+
+                inferred = {**_infer_alignments(headers, rows), **(alignments or {})}
+                screaming_alignments = {_to_header(k): v for k, v in inferred.items()}
+                _print_flush(
+                    tabulate(
+                        cast("list[list[str | int]]", formatted_rows),
+                        headers=screaming_headers,
+                        alignments=screaming_alignments,
+                    ),
+                )
+                if is_truncated:
+                    self.hint("Use `--no-truncate` or `--format json` to display full values.")
+            case OutputFormat.agent:  # TSV, no truncation, full timestamps
+                _print_flush("\t".join(headers))
+                for row in rows:
+                    _print_flush("\t".join(_format_table_cell_agent(v) for v in row))
+            case OutputFormat.json:  # compact JSON array
+                _print_flush(json.dumps(list(items), default=str))
+            case OutputFormat.quiet:  # id_key column (or first column), one per line
+                quiet_key = id_key or headers[0]
+                for item in items:
+                    _print_flush(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 == OutputFormat.quiet and id_key is not None:
+            _print_flush(data.get(id_key, ""))
+            return
+        indent = 2 if self.mode == OutputFormat.human else None
+        _print_flush(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 OutputFormat.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_flush("\n".join(parts))
+            case OutputFormat.agent:  # key=val pairs, space-separated
+                parts = [f"{k}={v}" for k, v in data.items() if v is not None]
+                _print_flush(" ".join(parts) if parts else message)
+            case OutputFormat.json:  # json.dumps(data), message ignored
+                _print_flush(json.dumps(data, default=str) if data else "")
+            case OutputFormat.quiet:  # first value only
+                values = list(data.values())
+                if values:
+                    _print_flush(values[0])
+
+    def confirm(self, message: str, *, default: bool = False, yes: bool = False, confirm_param: str = "--yes") -> None:
+        """
+        Ask for confirmation. Raises `ConfirmationError` in non-human modes.
+        """
+        if yes:
+            return
+        if self.mode != OutputFormat.human:
+            raise ConfirmationError(f"{message} Use {confirm_param} to skip confirmation.")
+        click.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 == OutputFormat.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 == OutputFormat.human:
+            _print_flush(ANSI.yellow(f"Warning: {message}"), file=sys.stderr)
+        else:
+            _print_flush(f"Warning: {message}", file=sys.stderr)
+
+    def error(self, message: str) -> None:
+        """Print an error to stderr (all modes)."""
+        if self.mode == OutputFormat.human:
+            _print_flush(ANSI.red(f"Error: {message}"), file=sys.stderr)
+        else:
+            _print_flush(f"Error: {message}", file=sys.stderr)
+
+    def log(self, message: str) -> None:
+        """Print a text message to stderr (human: gray, json/agent: plain text).
+
+        Suppressed in quiet mode. Kept in json mode (like agent) since agents
+        commonly run with ``--format json`` and the message goes to stderr so
+        it never pollutes the parsed stdout.
+        """
+        if self.mode == OutputFormat.quiet:
+            return
+        if self.mode == OutputFormat.human:
+            _print_flush(ANSI.gray(message), file=sys.stderr)
+        else:
+            _print_flush(message, file=sys.stderr)
+
+    def hint(self, message: str) -> None:
+        """Print a helpful hint to stderr (human: gray, json/agent: plain text).
+
+        Suppressed in quiet mode. Kept in json mode (like agent) since agents
+        commonly run with ``--format json`` and the next-command hints are useful
+        there; hints go to stderr so they never pollute the parsed stdout.
+        """
+        self.log(f"Hint: {message}")
+
+
+# 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")
+
+
+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 _infer_alignments(headers: list[str], rows: list[list[Any]]) -> dict[str, str]:
+    """Return ``{"col": "right"}`` for columns where every non-None value is numeric."""
+    result: dict[str, str] = {}
+    for c, h in enumerate(headers):
+        if all(row[c] is None or (isinstance(row[c], (int, float)) and not isinstance(row[c], bool)) for row in rows):
+            result[h] = "right"
+    return result
+
+
+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 _truncate_columns(
+    headers: list[str],
+    rows: list[list[str]],
+    *,
+    no_truncate: bool,
+) -> bool:
+    """Truncate cells in-place to fit the current terminal width.
+
+    Returns `True` if any cell was truncated, so the caller can emit a hint.
+    `shutil.get_terminal_size` is cross-platform: it honors `$COLUMNS`, then
+    queries the OS-native API, then falls back to `(80, 24)`.
+    """
+    if no_truncate or not rows:
+        return False
+
+    n = len(headers)
+    # Per-column natural width: longest of header label and cell values.
+    natural = [max(len(headers[c]), *(len(rows[r][c]) for r in range(len(rows)))) for c in range(n)]
+
+    # `max(0, n - 1)` accounts for the single-space separator between columns.
+    budget = shutil.get_terminal_size().columns - max(0, n - 1)
+    if sum(natural) <= budget:
+        return False
+
+    # Shrink the widest column 1 char at a time. Floors keep the header label
+    # visible; the `4` is the smallest cap that still shows "x..." (one content
+    # char plus the "..." marker).
+    caps = natural.copy()
+    min_widths = [max(len(h), 4) for h in headers]
+    while sum(caps) > budget:
+        widest = max(
+            (i for i, w in enumerate(caps) if w > min_widths[i]),
+            key=lambda i: caps[i],
+            default=-1,
+        )
+        if widest < 0:
+            break  # everything at floor — table wraps slightly
+        caps[widest] -= 1
+
+    truncated = False
+    for row in rows:
+        for c, cell in enumerate(row):
+            if len(cell) > caps[c]:
+                truncated = True
+                row[c] = cell[: caps[c] - 3] + "..."
+    return truncated
+
+
+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()

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/_skills.py

@@ -0,0 +1,311 @@
+"""Internal helpers for Hugging Face marketplace skill installation and upgrades."""
+
+import json
+import re
+import shutil
+import tempfile
+from collections.abc import Callable
+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_SKILL_ID = "hf-cli"
+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
+    description: str | None = None
+
+
+@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 install_generated_skill(content: str, destination_root: Path, force: bool = False) -> Path:
+    """Install the `hf-cli` skill from locally generated SKILL.md content (no bucket download)."""
+
+    def populate(install_dir: Path) -> None:
+        install_dir.mkdir(parents=True, exist_ok=True)
+        (install_dir / "SKILL.md").write_text(content, encoding="utf-8")
+        (install_dir / MANAGED_MARKER_FILENAME).touch()
+
+    return _install_skill(DEFAULT_SKILL_ID, destination_root, populate=populate, force=force)
+
+
+def update_skills(roots: list[Path], selector: str | None = None, *, hf_cli_content: str) -> list[SkillUpdateInfo]:
+    """Re-sync managed skill installs (`hf-cli` is rewritten from `hf_cli_content`, the rest 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}`.")
+
+    # `hf-cli` is regenerated locally, so only hit the marketplace when another managed skill needs it.
+    needs_marketplace = any(d.name != DEFAULT_SKILL_ID and (d / MANAGED_MARKER_FILENAME).exists() for d in skill_dirs)
+    api = None
+    marketplace_skills: dict[str, MarketplaceSkill] = {}
+    if needs_marketplace:
+        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, hf_cli_content) 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
+        description = plugin.get("description")
+        skills.append(
+            MarketplaceSkill(
+                name=name,
+                repo_path=_normalize_repo_path(source),
+                description=description if isinstance(description, str) else None,
+            )
+        )
+    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."""
+
+    def populate(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()
+
+    return _install_skill(skill.name, destination_root, populate=populate, force=force)
+
+
+_VALID_SKILL_NAME = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]*")
+
+
+def _install_skill(
+    name: str,
+    destination_root: Path,
+    populate: Callable[[Path], None],
+    force: bool = False,
+) -> Path:
+    """Install a skill into ``destination_root`` by calling ``populate(install_dir)`` to fill it.
+
+    Used by both the marketplace install (populate = download from bucket) and the
+    locally-generated install (populate = write content). When the install already
+    exists and ``force`` is set, the new content is staged in a sibling tempdir and
+    atomically swapped in, so the existing install stays intact if ``populate``
+    fails halfway through.
+    """
+    # `name` may come from the remote marketplace payload and the install dir is removed on
+    # reinstall: validate it as defense-in-depth against path traversal.
+    if not _VALID_SKILL_NAME.fullmatch(name):
+        raise CLIError(f"Invalid skill name '{name}'.")
+    destination_root = destination_root.expanduser().resolve()
+    destination_root.mkdir(parents=True, exist_ok=True)
+    install_dir = destination_root / name
+    already_exists = install_dir.exists()
+
+    if already_exists and not force:
+        raise FileExistsError(f"Skill already exists: {install_dir}")
+
+    if already_exists:
+        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(staged_dir)
+            _atomic_replace_directory(existing_dir=install_dir, staged_dir=staged_dir)
+        return install_dir
+
+    try:
+        populate(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 _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], hf_cli_content: str
+) -> SkillUpdateInfo:
+    base = SkillUpdateInfo(name=skill_dir.name, skill_dir=skill_dir, status="unmanaged")
+
+    if not (skill_dir / MANAGED_MARKER_FILENAME).exists():
+        return base
+
+    if skill_dir.name == DEFAULT_SKILL_ID:
+        try:
+            install_generated_skill(hf_cli_content, 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")
+
+    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")

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/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."""
+
+from typing import Annotated
+
+import click
+
+from huggingface_hub.constants import ENDPOINT
+from huggingface_hub.hf_api import whoami
+
+from .._login import _save_oauth_token, auth_list, auth_switch, login, logout
+from ..errors import CLIError
+from ..utils import get_stored_tokens, get_token, logging, select_choice
+from ..utils._oauth_device import poll_device_token, request_device_code
+from ._cli_utils import TokenOpt, typer_factory
+from ._framework import Option
+from ._output import OutputFormat, 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,
+        Option(
+            help="Save to git credential helper. Useful only if you plan to run git commands directly.",
+        ),
+    ] = False,
+    force: Annotated[
+        bool,
+        Option(
+            help="Force re-login even if already logged in.",
+        ),
+    ] = False,
+) -> None:
+    """Login from your browser, or using a token from huggingface.co/settings/tokens."""
+    if token is not None or out.mode == OutputFormat.human:
+        # `--token` bypasses any prompt; in human mode the gh-style menu lives in `login()`.
+        login(token=token, add_to_git_credential=add_to_git_credential, skip_if_logged_in=not force)
+        return
+
+    # Logging in is an interactive flow: besides human mode, only agent mode is supported.
+    if out.mode != OutputFormat.agent:
+        raise CLIError(
+            "`hf auth login` is interactive and does not support --format json/quiet. "
+            "Pass --token for a non-interactive login."
+        )
+
+    # agent mode: never prompt; print instructions the agent can relay to its user.
+    if not force and get_token() is not None:
+        out.text(agent="Already logged in. Use `hf auth login --force` to re-login.")
+        return
+    device_info = request_device_code()
+    out.text(
+        agent=(
+            f"Ask the user to open {device_info['verification_uri_complete']} in a browser and enter the code "
+            f"{device_info['user_code']}. The code expires in {device_info['expires_in']} seconds. "
+            "Waiting for authorization..."
+        )
+    )
+    response = poll_device_token(device_info)
+    token_name, username = _save_oauth_token(response)
+    out.text(agent=f"Login successful: logged in as {username} (token saved as '{token_name}').")
+
+
+@auth_cli.command(
+    "logout",
+    examples=["hf auth logout", "hf auth logout --token-name my-token"],
+)
+def auth_logout(
+    token_name: Annotated[
+        str | None,
+        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
+
+    if out.mode != OutputFormat.human:
+        raise CLIError("Use --token-name to select a token in non-interactive mode.")
+    return token_names[select_choice("Select a token to switch to:", token_names)]
+
+
+@auth_cli.command(
+    "switch",
+    examples=["hf auth switch", "hf auth switch --token-name my-token"],
+)
+def auth_switch_cmd(
+    token_name: Annotated[
+        str | None,
+        Option(
+            help="Name of the token to switch to",
+        ),
+    ] = None,
+    add_to_git_credential: Annotated[
+        bool,
+        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 click.exceptions.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 click.exceptions.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 click.exceptions.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)

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/buckets.py

@@ -0,0 +1,679 @@
+# 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."""
+
+from typing import Annotated
+
+import click
+
+from huggingface_hub import logging
+from huggingface_hub._buckets import (
+    BUCKET_PREFIX,
+    BucketFile,
+    FilterMatcher,
+    _parse_bucket_uri,
+)
+
+from ..hf_api import REPO_REGIONS
+from ._cli_utils import (
+    SearchOpt,
+    TokenOpt,
+    get_hf_api,
+    typer_factory,
+)
+from ._cp import make_cp
+from ._file_listing import format_size, print_file_listing
+from ._framework import Argument, Option
+from ._output import OutputFormat, out
+
+
+logger = logging.get_logger(__name__)
+
+
+buckets_cli = typer_factory(help="Commands to interact with buckets.")
+
+
+@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",
+        "hf buckets create user/my-bucket --region us",
+    ],
+)
+def create(
+    bucket_id: Annotated[
+        str,
+        Argument(
+            help="Bucket ID: bucket_name, namespace/bucket_name, or hf://buckets/namespace/bucket_name",
+        ),
+    ],
+    private: Annotated[
+        bool,
+        Option(
+            "--private",
+            help="Create a private bucket.",
+        ),
+    ] = False,
+    region: Annotated[
+        REPO_REGIONS | None,
+        Option(
+            "--region",
+            help="Cloud region in which to create the bucket. Can be one of 'us' or 'eu'. Requires Team plan or above.",
+        ),
+    ] = None,
+    exist_ok: Annotated[
+        bool,
+        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):
+        parsed = _parse_bucket_uri(bucket_id)
+        if parsed.path_in_repo:
+            raise click.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,
+        region=region,
+        exist_ok=exist_ok,
+    )
+    out.result("Bucket created", uri=bucket_url.uri.to_uri(), 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,
+        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,
+        Option(
+            "--human-readable",
+            "-h",
+            help="Show sizes in human readable format.",
+        ),
+    ] = False,
+    as_tree: Annotated[
+        bool,
+        Option(
+            "--tree",
+            help="List files in tree format (only for listing files).",
+        ),
+    ] = False,
+    recursive: Annotated[
+        bool,
+        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 click.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 click.BadParameter("Cannot use --tree when listing buckets.")
+    if recursive:
+        raise click.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"})
+
+
+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 == OutputFormat.json:
+        raise click.BadParameter("Cannot use --tree with --format json.")
+
+    api = get_hf_api(token=token)
+    parsed = _parse_bucket_uri(argument)
+    items = list(
+        api.list_bucket_tree(
+            parsed.id,
+            prefix=parsed.path_in_repo 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,
+        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)
+    parsed = _parse_bucket_uri(bucket_id)
+    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,
+        Argument(
+            help="Bucket ID: namespace/bucket_name or hf://buckets/namespace/bucket_name",
+        ),
+    ],
+    yes: Annotated[
+        bool,
+        Option(
+            "--yes",
+            "-y",
+            help="Skip confirmation prompt.",
+        ),
+    ] = False,
+    missing_ok: Annotated[
+        bool,
+        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):
+        parsed = _parse_bucket_uri(bucket_id)
+        if parsed.path_in_repo:
+            raise click.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 click.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,
+        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,
+        Option(
+            "--recursive",
+            "-R",
+            help="Remove files recursively under the given prefix.",
+        ),
+    ] = False,
+    yes: Annotated[
+        bool,
+        Option(
+            "--yes",
+            "-y",
+            help="Skip confirmation prompt.",
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        Option(
+            "--dry-run",
+            help="Preview what would be deleted without actually deleting.",
+        ),
+    ] = False,
+    include: Annotated[
+        list[str] | None,
+        Option(
+            help="Include only files matching pattern (can specify multiple). Requires --recursive.",
+        ),
+    ] = None,
+    exclude: Annotated[
+        list[str] | None,
+        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.
+    """
+    parsed = _parse_bucket_uri(argument)
+    bucket_id = parsed.id
+    prefix = parsed.path_in_repo
+
+    if prefix == "" and not recursive:
+        raise click.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 click.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 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
+        if not file_path:
+            raise click.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,
+        Argument(
+            help="Source bucket ID: namespace/bucket_name or hf://buckets/namespace/bucket_name",
+        ),
+    ],
+    to_id: Annotated[
+        str,
+        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 = _parse_bucket_uri(from_id)
+    if parsed_from.path_in_repo:
+        raise click.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 = _parse_bucket_uri(to_id)
+    if parsed_to.path_in_repo:
+        raise click.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,
+        Argument(
+            help="Source path: local directory or hf://buckets/namespace/bucket_name(/prefix)",
+        ),
+    ] = None,
+    dest: Annotated[
+        str | None,
+        Argument(
+            help="Destination path: local directory or hf://buckets/namespace/bucket_name(/prefix)",
+        ),
+    ] = None,
+    delete: Annotated[
+        bool,
+        Option(
+            help="Delete destination files not present in source.",
+        ),
+    ] = False,
+    ignore_times: Annotated[
+        bool,
+        Option(
+            "--ignore-times",
+            help="Skip files only based on size, ignoring modification times.",
+        ),
+    ] = False,
+    ignore_sizes: Annotated[
+        bool,
+        Option(
+            "--ignore-sizes",
+            help="Skip files only based on modification times, ignoring sizes.",
+        ),
+    ] = False,
+    plan: Annotated[
+        str | None,
+        Option(
+            help="Save sync plan to JSONL file for review instead of executing.",
+        ),
+    ] = None,
+    apply: Annotated[
+        str | None,
+        Option(
+            help="Apply a previously saved plan file.",
+        ),
+    ] = None,
+    dry_run: Annotated[
+        bool,
+        Option(
+            "--dry-run",
+            help="Print sync plan to stdout as JSONL without executing.",
+        ),
+    ] = False,
+    include: Annotated[
+        list[str] | None,
+        Option(
+            help="Include files matching pattern (can specify multiple).",
+        ),
+    ] = None,
+    exclude: Annotated[
+        list[str] | None,
+        Option(
+            help="Exclude files matching pattern (can specify multiple).",
+        ),
+    ] = None,
+    filter_from: Annotated[
+        str | None,
+        Option(
+            help="Read include/exclude patterns from file.",
+        ),
+    ] = None,
+    existing: Annotated[
+        bool,
+        Option(
+            "--existing",
+            help="Skip creating new files on receiver (only update existing files).",
+        ),
+    ] = False,
+    ignore_existing: Annotated[
+        bool,
+        Option(
+            "--ignore-existing",
+            help="Skip updating files that exist on receiver (only create new files).",
+        ),
+    ] = False,
+    verbose: Annotated[
+        bool,
+        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
+# =============================================================================
+
+
+# `hf buckets cp` is an alias for the top-level `hf cp` command (see `cli/_cp.py`).
+buckets_cli.command(
+    name="cp",
+    examples=[
+        # Download (repo or bucket -> local / stdout)
+        "hf buckets cp hf://buckets/username/my-bucket/config.json config.json",
+        "hf buckets cp hf://buckets/username/my-bucket/data.csv data/",
+        "hf buckets cp hf://buckets/username/my-bucket/config.json -",
+        # Upload (local / stdin -> bucket)
+        "hf buckets cp model.safetensors hf://buckets/username/my-bucket/model.safetensors",
+        "hf buckets cp config.json hf://buckets/username/my-bucket/logs/",
+        "hf buckets cp - hf://buckets/username/my-bucket/config.json",
+        # Remote to remote (repo or bucket -> bucket)
+        "hf buckets cp hf://buckets/username/my-bucket/data.csv hf://buckets/username/dest-bucket/",
+        "hf buckets cp hf://buckets/username/source-bucket/logs/ hf://buckets/username/dest-bucket/logs/",
+    ],
+)(make_cp("buckets"))

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/cache.py

@@ -0,0 +1,800 @@
+# 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 click
+
+from huggingface_hub.errors import CLIError
+
+from ..utils import (
+    ANSI,
+    CachedRepoInfo,
+    CachedRevisionInfo,
+    CacheNotFound,
+    HFCacheInfo,
+    _format_size,
+    parse_hf_uri,
+    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 ._framework import Argument, Option
+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 _prune_summary(revision_count: int, incomplete_count: int) -> str:
+    """Build the human-readable summary of what `hf cache prune` is about to delete."""
+    parts: list[str] = []
+    if revision_count:
+        parts.append(f"{revision_count} unreferenced revision(s)")
+    if incomplete_count:
+        parts.append(f"{incomplete_count} incomplete download(s)")
+    return " and ".join(parts)
+
+
+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 _repo_cache_id_from_target(target: str) -> str:
+    """Return the cache id matching a repo target passed to `hf cache rm`."""
+    if not target.startswith("hf://"):
+        return target
+
+    uri = parse_hf_uri(target)
+    if not uri.is_repo:
+        raise CLIError("Only repository hf:// URIs are supported by `hf cache rm`.")
+    if uri.revision is not None or uri.path_in_repo:
+        raise CLIError("Only repo-level hf:// URIs are supported by `hf cache rm` for now.")
+    return f"{uri.type}/{uri.id}"
+
+
+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(_repo_cache_id_from_target(target).lower())
+        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,
+        Option(
+            help="Cache directory to scan (defaults to Hugging Face cache).",
+        ),
+    ] = None,
+    revisions: Annotated[
+        bool,
+        Option(
+            help="Include revisions in the output instead of aggregated repositories.",
+        ),
+    ] = False,
+    filter: Annotated[
+        list[str] | None,
+        Option(
+            "-f",
+            "--filter",
+            help="Filter entries (e.g. 'size>1GB', 'type=model', 'accessed>7d'). Can be used multiple times.",
+        ),
+    ] = None,
+    sort: Annotated[
+        SortOptions | None,
+        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,
+        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 click.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 click.BadParameter(str(exc)) from exc
+
+    # Apply limit if requested
+    if limit is not None:
+        if limit < 0:
+            raise click.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."
+            )
+        )
+
+    incomplete_files = hf_cache_info.incomplete_files
+    if incomplete_files:
+        out.hint(
+            f"Found {len(incomplete_files)} incomplete download(s) totalling "
+            f"{_format_size(hf_cache_info.incomplete_size_on_disk)}. "
+            "Remove them with 'hf cache prune'."
+        )
+
+
+@cache_cli.command(
+    examples=[
+        "hf cache rm model/gpt2",
+        "hf cache rm hf://models/openai-community/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],
+        Argument(
+            help="One or more repo IDs (e.g. model/bert-base-uncased), repo-level hf:// URIs, or revision hashes to delete.",
+        ),
+    ],
+    cache_dir: Annotated[
+        str | None,
+        Option(
+            help="Cache directory to scan (defaults to Hugging Face cache).",
+        ),
+    ] = None,
+    yes: Annotated[
+        bool,
+        Option(
+            "-y",
+            "--yes",
+            help="Skip confirmation prompt.",
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        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 click.exceptions.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,
+        Option(
+            help="Cache directory to scan (defaults to Hugging Face cache).",
+        ),
+    ] = None,
+    yes: Annotated[
+        bool,
+        Option(
+            "-y",
+            "--yes",
+            help="Skip confirmation prompt.",
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        Option(
+            help="Preview deletions without removing anything.",
+        ),
+    ] = False,
+) -> None:
+    """Remove detached revisions and incomplete downloads 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)
+
+    incomplete_files = hf_cache_info.incomplete_files
+
+    if len(revisions) == 0 and not incomplete_files:
+        out.text("No unreferenced revisions or incomplete downloads found. Nothing to prune.")
+        return
+
+    strategy = hf_cache_info.delete_revisions(*sorted(revisions))
+    counts = summarize_deletions(selected)
+    total_freed = strategy.expected_freed_size + hf_cache_info.incomplete_size_on_disk
+
+    summary = _prune_summary(counts.total_revision_count, len(incomplete_files))
+    out.text(f"About to delete {summary} ({_format_size(total_freed)} 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,
+            incomplete=len(incomplete_files),  # might be overstated but it's fine
+            size=_format_size(total_freed),
+        )
+        return
+
+    out.confirm("Proceed?", yes=yes)
+
+    strategy.execute()
+    for incomplete_file in incomplete_files:
+        try:
+            incomplete_file.file_path.unlink()
+        except FileNotFoundError:
+            pass  # already removed (e.g. by a full-repo deletion above)
+        except OSError as exc:
+            out.warning(f"Could not delete incomplete file {incomplete_file.file_path}: {exc}")
+    out.result(
+        f"Deleted {summary}; freed {_format_size(total_freed)}.",
+        revisions_deleted=counts.total_revision_count,
+        incomplete_deleted=len(incomplete_files),
+        freed=_format_size(total_freed),
+    )
+
+
+@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,
+        Option(
+            help="Cache directory to use when verifying files from cache (defaults to Hugging Face cache).",
+        ),
+    ] = None,
+    local_dir: Annotated[
+        str | None,
+        Option(
+            help="If set, verify files under this directory instead of the cache.",
+        ),
+    ] = None,
+    fail_on_missing_files: Annotated[
+        bool,
+        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,
+        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 click.exceptions.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 click.exceptions.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),
+    )

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/collections.py

@@ -0,0 +1,293 @@
+# 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."""
+
+import enum
+from typing import Annotated, get_args
+
+from huggingface_hub.hf_api import CollectionItemType_T, CollectionSort_T
+
+from ._cli_utils import LimitOpt, TokenOpt, get_hf_api, typer_factory
+from ._framework import Argument, Option
+from ._output import _dataclass_to_dict, 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,
+        Option(help="Filter by owner username or organization."),
+    ] = None,
+    item: Annotated[
+        str | None,
+        Option(
+            help='Filter collections containing a specific item (e.g., "models/gpt2", "datasets/squad", "papers/2311.12983").'
+        ),
+    ] = None,
+    sort: Annotated[
+        CollectionSort | None,
+        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 = [
+        _dataclass_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, 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, Argument(help="The title of the collection.")],
+    namespace: Annotated[
+        str | None,
+        Option(help="The namespace (username or organization). Defaults to the authenticated user."),
+    ] = None,
+    description: Annotated[
+        str | None,
+        Option(help="A description for the collection."),
+    ] = None,
+    private: Annotated[
+        bool,
+        Option(help="Create a private collection."),
+    ] = False,
+    exists_ok: Annotated[
+        bool,
+        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, Argument(help="The collection slug (e.g., 'username/collection-slug').")],
+    title: Annotated[
+        str | None,
+        Option(help="The new title for the collection."),
+    ] = None,
+    description: Annotated[
+        str | None,
+        Option(help="The new description for the collection."),
+    ] = None,
+    position: Annotated[
+        int | None,
+        Option(help="The new position of the collection in the owner's list."),
+    ] = None,
+    private: Annotated[
+        bool | None,
+        Option(help="Whether the collection should be private."),
+    ] = None,
+    theme: Annotated[
+        str | None,
+        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, Argument(help="The collection slug (e.g., 'username/collection-slug').")],
+    missing_ok: Annotated[
+        bool,
+        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, Argument(help="The collection slug (e.g., 'username/collection-slug').")],
+    item_id: Annotated[str, Argument(help="The ID of the item to add (repo_id for repos, paper ID for papers).")],
+    item_type: Annotated[
+        CollectionItemType,
+        Argument(help="The type of item (model, dataset, space, paper, collection, or bucket)."),
+    ],
+    note: Annotated[
+        str | None,
+        Option(help="A note to attach to the item (max 500 characters)."),
+    ] = None,
+    exists_ok: Annotated[
+        bool,
+        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, Argument(help="The collection slug (e.g., 'username/collection-slug').")],
+    item_object_id: Annotated[
+        str,
+        Argument(help="The ID of the item in the collection (from 'item_object_id' field, not the repo_id)."),
+    ],
+    note: Annotated[
+        str | None,
+        Option(help="A new note for the item (max 500 characters)."),
+    ] = None,
+    position: Annotated[
+        int | None,
+        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, Argument(help="The collection slug (e.g., 'username/collection-slug').")],
+    item_object_id: Annotated[
+        str,
+        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,
+        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)

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/datasets.py

@@ -0,0 +1,274 @@
+# 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."""
+
+import enum
+from typing import Annotated, get_args
+
+import click
+
+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,
+    get_hf_api,
+    make_expand_properties_parser,
+    typer_factory,
+)
+from ._file_listing import list_repo_files_cmd
+from ._framework import Argument, Option
+from ._output import _dataclass_to_dict, 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,
+    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,
+        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,
+        Option(help="Sort results."),
+    ] = None,
+    limit: LimitOpt = REPO_LIST_DEFAULT_LIMIT,
+    expand: ExpandOpt = None,
+    human_readable: Annotated[
+        bool,
+        Option("--human-readable", "-h", help="Show sizes in human readable format (only for listing files)."),
+    ] = False,
+    as_tree: Annotated[
+        bool,
+        Option("--tree", help="List files in tree format (only for listing files)."),
+    ] = False,
+    recursive: Annotated[
+        bool,
+        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 click.BadParameter("Cannot use --search when listing files.")
+        if author is not None:
+            raise click.BadParameter("Cannot use --author when listing files.")
+        if filter is not None:
+            raise click.BadParameter("Cannot use --filter when listing files.")
+        if sort is not None:
+            raise click.BadParameter("Cannot use --sort when listing files.")
+        if limit != REPO_LIST_DEFAULT_LIMIT:
+            raise click.BadParameter("Cannot use --limit when listing files.")
+        if expand is not None:
+            raise click.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 click.BadParameter("Cannot use --tree when listing datasets.")
+    if recursive:
+        raise click.BadParameter("Cannot use --recursive when listing datasets.")
+    if human_readable:
+        raise click.BadParameter("Cannot use --human-readable when listing datasets.")
+    if revision is not None:
+        raise click.BadParameter("Cannot use --revision when listing datasets.")
+
+    api = get_hf_api(token=token)
+    sort_key = sort.value if sort else None
+    results = [
+        _dataclass_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, 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 = [_dataclass_to_dict(entry) for entry in leaderboard[:limit]]
+    out.table(
+        results,
+        headers=["rank", "model_id", "value", "source"],
+        id_key="model_id",
+    )
+    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, 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, Argument(help="The dataset ID (e.g. `username/repo-name`).")],
+    subset: Annotated[str | None, Option("--subset", help="Filter parquet entries by subset/config.")] = None,
+    split: Annotated[str | None, 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, 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, Argument(help="The dataset ID (e.g. `username/repo-name`).")],
+    metadata: Annotated[bool, Option("--metadata", help="Output only the metadata from the card.")] = False,
+    text: Annotated[bool, 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.")

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/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)

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/discussions.py

@@ -0,0 +1,497 @@
+# 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 click
+
+from huggingface_hub import constants
+
+from ._cli_utils import (
+    AuthorOpt,
+    LimitOpt,
+    RepoIdArg,
+    RepoType,
+    RepoTypeOpt,
+    TokenOpt,
+    get_hf_api,
+    typer_factory,
+)
+from ._framework import Argument, Option
+from ._output import _dataclass_to_dict, 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,
+    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 click.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,
+        Option(
+            "-s",
+            "--status",
+            help="Filter by status (open, closed, merged, draft, all).",
+        ),
+    ] = DiscussionStatus.open,
+    kind: Annotated[
+        DiscussionKind,
+        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 = [_dataclass_to_dict(d) for d in discussions]
+    out.table(
+        items,
+        headers=["num", "title", "is_pull_request", "status", "author", "created_at"],
+        id_key="num",
+    )
+
+
+@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,
+        Option(
+            "--title",
+            help="The title of the discussion or pull request.",
+        ),
+    ],
+    body: Annotated[
+        str | None,
+        Option(
+            "--body",
+            help="The description (supports Markdown).",
+        ),
+    ] = None,
+    body_file: Annotated[
+        Path | None,
+        Option(
+            "--body-file",
+            help="Read the description from a file. Use '-' for stdin.",
+        ),
+    ] = None,
+    pull_request: Annotated[
+        bool,
+        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,
+        Option(
+            "--body",
+            help="The comment text (supports Markdown).",
+        ),
+    ] = None,
+    body_file: Annotated[
+        Path | None,
+        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 click.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(
+    "edit",
+    examples=[
+        'hf discussions edit username/my-model 5 abc123 --body "Updated comment."',
+        "hf discussions edit username/my-model 5 abc123 --body-file fixed.md",
+    ],
+)
+def discussion_edit(
+    repo_id: RepoIdArg,
+    num: DiscussionNumArg,
+    comment_id: Annotated[
+        str,
+        Argument(
+            help="The ID of the comment to edit (see 'hf discussions info ... --format json').",
+        ),
+    ],
+    body: Annotated[
+        str | None,
+        Option(
+            "--body",
+            help="The new comment text (supports Markdown).",
+        ),
+    ] = None,
+    body_file: Annotated[
+        Path | None,
+        Option(
+            "--body-file",
+            help="Read the new comment from a file. Use '-' for stdin.",
+        ),
+    ] = None,
+    repo_type: RepoTypeOpt = RepoType.model,
+    token: TokenOpt = None,
+) -> None:
+    """Edit an existing comment on a discussion or pull request."""
+    new_content = _read_body(body, body_file)
+    if new_content is None:
+        raise click.BadParameter("Either --body or --body-file is required.")
+    api = get_hf_api(token=token)
+    api.edit_discussion_comment(
+        repo_id=repo_id,
+        discussion_num=num,
+        comment_id=comment_id,
+        new_content=new_content,
+        repo_type=repo_type.value,
+    )
+    out.result(f"Edited comment {comment_id} on #{num} in {repo_id}", num=num, repo=repo_id, comment_id=comment_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,
+        Option(
+            "--comment",
+            help="An optional comment to post when closing.",
+        ),
+    ] = None,
+    yes: Annotated[
+        bool,
+        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,
+        Option(
+            "--comment",
+            help="An optional comment to post when reopening.",
+        ),
+    ] = None,
+    yes: Annotated[
+        bool,
+        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,
+        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,
+        Option(
+            "--comment",
+            help="An optional comment to post when merging.",
+        ),
+    ] = None,
+    yes: Annotated[
+        bool,
+        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.")

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/download.py

@@ -0,0 +1,225 @@
+# Copyright 202-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 command to download files from the Hub with the CLI."""
+
+import warnings
+from typing import Annotated
+
+from huggingface_hub import constants
+from huggingface_hub._snapshot_download import snapshot_download
+from huggingface_hub.errors import CLIError
+from huggingface_hub.file_download import DryRunFileInfo, hf_hub_download
+from huggingface_hub.utils import _format_size, parse_hf_uri
+
+from ._cli_utils import RepoIdArg, RepoType, RepoTypeOptionalOpt, RevisionOpt, TokenOpt
+from ._framework import Argument, Option
+from ._output import out
+
+
+DOWNLOAD_EXAMPLES = [
+    "hf download meta-llama/Llama-3.2-1B-Instruct",
+    "hf download meta-llama/Llama-3.2-1B-Instruct config.json tokenizer.json",
+    'hf download meta-llama/Llama-3.2-1B-Instruct --include "*.safetensors" --exclude "*.bin"',
+    "hf download meta-llama/Llama-3.2-1B-Instruct --local-dir ./models/llama",
+    "hf download HuggingFaceM4/FineVision art/ --repo-type dataset",
+    "hf download hf://datasets/HuggingFaceH4/ultrachat_200k",
+]
+
+
+def download(
+    repo_id: RepoIdArg,
+    filenames: Annotated[
+        list[str] | None,
+        Argument(
+            help="Files to download (e.g. `config.json`, `data/metadata.jsonl`).",
+        ),
+    ] = None,
+    repo_type: RepoTypeOptionalOpt = None,
+    revision: RevisionOpt = None,
+    include: Annotated[
+        list[str] | None,
+        Option(
+            help="Glob patterns to include from files to download. eg: *.json",
+        ),
+    ] = None,
+    exclude: Annotated[
+        list[str] | None,
+        Option(
+            help="Glob patterns to exclude from files to download.",
+        ),
+    ] = None,
+    cache_dir: Annotated[
+        str | None,
+        Option(
+            help="Directory where to save files.",
+        ),
+    ] = None,
+    local_dir: Annotated[
+        str | None,
+        Option(
+            help="If set, the downloaded file will be placed under this directory. Check out https://huggingface.co/docs/huggingface_hub/guides/download#download-files-to-a-local-folder for more details.",
+        ),
+    ] = None,
+    force_download: Annotated[
+        bool,
+        Option(
+            help="If True, the files will be downloaded even if they are already cached.",
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        Option(
+            help="If True, perform a dry run without actually downloading the file.",
+        ),
+    ] = False,
+    token: TokenOpt = None,
+    max_workers: Annotated[
+        int,
+        Option(
+            help="Maximum number of workers to use for downloading files. Default is 8.",
+        ),
+    ] = 8,
+) -> None:
+    """Download files from the Hub."""
+    if local_dir is not None and cache_dir is not None:
+        raise CLIError(
+            "Cannot use both `--local-dir` and `--cache-dir` at the same time. "
+            "Use `--cache-dir` (or set the HF_HOME environment variable) for shared caching, "
+            "or `--local-dir` for a one-off download to a specific directory."
+        )
+
+    # `repo_id` may be a plain repo id or an `hf://` URI (e.g. `hf://datasets/my-org/my-dataset@v1.0/data/`).
+    # When a URI is provided, it is authoritative for the repo type, revision and (optionally) file path,
+    # so explicit `--repo-type` / `--revision` options are forbidden alongside it.
+    # We branch on the `hf://` prefix (the user's *intent*) rather than on whether the string parses as a
+    # valid URI: a malformed URI then surfaces a precise `HfUriError` (formatted globally in `cli/_errors.py`)
+    # instead of silently falling through to the plain-repo-id path and failing later with an opaque error.
+    if repo_id.startswith(constants.HF_PROTOCOL):
+        if repo_type is not None:
+            raise CLIError(f"'--repo-type' cannot be used with an 'hf://' URI ('{repo_id}').")
+        if revision is not None:
+            raise CLIError(f"'--revision' cannot be used with an 'hf://' URI ('{repo_id}').")
+        uri = parse_hf_uri(repo_id)
+        if uri.is_bucket:
+            raise CLIError("Buckets are not supported by `hf download`. Use `hf sync` instead.")
+        # The URI parser strips trailing slashes, but `hf download` uses a trailing '/' to denote a subfolder
+        # download (e.g. `data/` -> `data/**`). Re-append it when the URI explicitly ended with '/' so a folder
+        # URI keeps routing through the subfolder code path below.
+        path_in_repo = uri.path_in_repo
+        if path_in_repo and repo_id.endswith("/"):
+            path_in_repo += "/"
+        repo_id, repo_type_str, revision = uri.id, uri.type, uri.revision
+        if path_in_repo:
+            if filenames:
+                raise CLIError(
+                    f"Cannot combine a file path in the hf:// URI ('{path_in_repo}') with positional filenames {filenames}."
+                )
+            filenames = [path_in_repo]
+    else:
+        repo_type_str = (repo_type or RepoType.model).value
+
+    def run_download() -> str | DryRunFileInfo | list[DryRunFileInfo]:
+        filenames_list = filenames if filenames is not None else []
+
+        # Separate subfolder patterns (ending with '/') from regular filenames
+        # Subfolders like "art/" are converted to include patterns like "art/**"
+        subfolders = [f for f in filenames_list if f.endswith("/")]
+        subfolder_patterns = [f"{f.rstrip('/')}/**" for f in subfolders]
+        regular_filenames = [f for f in filenames_list if not f.endswith("/")]
+
+        # Error if subfolder patterns are combined with --include/--exclude
+        # Guide user to use --include instead of subfolder argument
+        if len(subfolder_patterns) > 0:
+            if include is not None and len(include) > 0:
+                raise CLIError(
+                    f"Cannot combine subfolder argument ('{subfolders[0]}') with `--include`. "
+                    f'Please use `--include "{subfolders[0]}*"` instead.'
+                )
+            if exclude is not None and len(exclude) > 0:
+                raise CLIError(
+                    f"Cannot combine subfolder argument ('{subfolders[0]}') with `--exclude`. "
+                    f'Please use `--include "{subfolders[0]}*"` with `--exclude` instead.'
+                )
+
+        # Warn user if patterns are ignored (only if regular filenames are provided)
+        if len(regular_filenames) > 0:
+            if include is not None and len(include) > 0:
+                warnings.warn("Ignoring `--include` since filenames have been explicitly set.")
+            if exclude is not None and len(exclude) > 0:
+                warnings.warn("Ignoring `--exclude` since filenames have been explicitly set.")
+
+        # Single file to download (not a subfolder): use `hf_hub_download`
+        if len(regular_filenames) == 1 and len(subfolder_patterns) == 0:
+            return hf_hub_download(
+                repo_id=repo_id,
+                repo_type=repo_type_str,
+                revision=revision,
+                filename=regular_filenames[0],
+                cache_dir=cache_dir,
+                force_download=force_download,
+                token=token,
+                local_dir=local_dir,
+                library_name="huggingface-cli",
+                dry_run=dry_run,
+            )
+
+        # Otherwise: use `snapshot_download` to ensure all files comes from same revision
+        if len(regular_filenames) == 0 and len(subfolder_patterns) == 0:
+            # No filenames provided: use include/exclude patterns
+            allow_patterns = include
+            ignore_patterns = exclude
+        else:
+            # Combine regular filenames and subfolder patterns as allow_patterns
+            allow_patterns = regular_filenames + subfolder_patterns
+            ignore_patterns = None
+
+        return snapshot_download(
+            repo_id=repo_id,
+            repo_type=repo_type_str,
+            revision=revision,
+            allow_patterns=allow_patterns,
+            ignore_patterns=ignore_patterns,
+            force_download=force_download,
+            cache_dir=cache_dir,
+            token=token,
+            local_dir=local_dir,
+            library_name="huggingface-cli",
+            max_workers=max_workers,
+            dry_run=dry_run,
+        )
+
+    def _print_result(result: str | DryRunFileInfo | list[DryRunFileInfo]) -> None:
+        if isinstance(result, str):
+            out.result("Downloaded", path=result)
+            return
+
+        # Print dry run info
+        if isinstance(result, DryRunFileInfo):
+            result = [result]
+        will_download = [r for r in result if r.will_download]
+        out.text(
+            f"[dry-run] Will download {len(will_download)} files"
+            f" (out of {len(result)})"
+            f" totalling {_format_size(sum(r.file_size for r in will_download))}."
+        )
+        items = [
+            {
+                "file": info.filename,
+                "size": _format_size(info.file_size) if info.will_download else "-",
+            }
+            for info in sorted(result, key=lambda x: x.filename)
+        ]
+        out.table(items)
+
+    _print_result(run_download())

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/extensions.py

@@ -0,0 +1,697 @@
+# 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 helper utilities for hf CLI extensions."""
+
+import errno
+import json
+import os
+import re
+import shutil
+import subprocess
+import venv
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Annotated, Literal
+
+import click
+
+from huggingface_hub.errors import CLIError, CLIExtensionInstallError, ConfirmationError
+from huggingface_hub.utils import get_session, logging
+
+from ._cli_utils import typer_factory
+from ._framework import Argument, Option
+from ._output import out
+
+
+DEFAULT_EXTENSION_OWNER = "huggingface"
+EXTENSIONS_ROOT = Path("~/.local/share/hf/extensions")
+MANIFEST_FILENAME = "manifest.json"
+EXTENSIONS_HELP = (
+    "Manage hf CLI extensions.\n\n"
+    "Security Warning: extensions are third-party executables or Python packages. "
+    "Install only from sources you trust."
+)
+extensions_cli = typer_factory(help=EXTENSIONS_HELP)
+_EXTENSIONS_GITHUB_TOPIC = "hf-extension"
+_EXTENSIONS_DOWNLOAD_TIMEOUT = 10
+_EXTENSIONS_PIP_INSTALL_TIMEOUT = 300
+
+logger = logging.get_logger(__name__)
+
+
+class _ExtensionUpdateStatus(str, Enum):
+    UPDATED = "updated"
+    UP_TO_DATE = "up_to_date"
+    SKIPPED = "skipped"
+
+
+@dataclass
+class ExtensionManifest:
+    owner: str
+    repo: str
+    repo_id: str
+    short_name: str
+    executable_path: str
+    type: Literal["binary", "python"]
+    installed_at: datetime
+    description: str | None = None
+    commit_sha: str | None = None
+
+    @classmethod
+    def load(cls, path: Path) -> "ExtensionManifest":
+        manifest_path = path / MANIFEST_FILENAME
+        if not manifest_path.is_file():
+            raise CLIError(f"Manifest file not found at {manifest_path}. Your extension may be corrupted.")
+        data = json.loads(manifest_path.read_text())
+        # Ignore keys not in the dataclass (e.g. fields dropped since the manifest was written).
+        data = {key: value for key, value in data.items() if key in cls.__dataclass_fields__}
+        data["installed_at"] = datetime.fromisoformat(data["installed_at"])
+        return ExtensionManifest(**data)
+
+    def save(self, path: Path) -> None:
+        manifest_path = path / MANIFEST_FILENAME
+        manifest_path.parent.mkdir(parents=True, exist_ok=True)
+        data = asdict(self)
+        data["installed_at"] = self.installed_at.isoformat()
+        manifest_path.write_text(json.dumps(data, indent=2, sort_keys=True))
+
+
+@extensions_cli.command(
+    "install",
+    examples=[
+        "hf extensions install hf-claude",
+        "hf extensions install hanouticelina/hf-claude",
+        "hf extensions install alvarobartt/hf-mem",
+    ],
+)
+def extension_install(
+    ctx: click.Context,
+    repo_id: Annotated[
+        str,
+        Argument(help="GitHub extension repository in `[OWNER/]hf-<name>` format."),
+    ],
+    force: Annotated[bool, Option("--force", help="Overwrite if already installed.")] = False,
+) -> None:
+    """Install an extension from a public GitHub repository.
+
+    Security warning: this installs a third-party executable or Python package.
+    Install only from sources you trust.
+    """
+    owner, repo_name, short_name = _normalize_repo_id(repo_id)
+    root_ctx = ctx.find_root()
+    reserved_commands = set(getattr(root_ctx.command, "commands", {}).keys())
+    if short_name in reserved_commands:
+        raise CLIError(
+            f"Cannot install extension '{short_name}' because it conflicts with an existing `hf {short_name}` command."
+        )
+
+    extension_dir = _get_extension_dir(short_name)
+    if extension_dir.exists() and not force:
+        raise CLIError(f"Extension '{short_name}' is already installed. Use --force to overwrite.")
+
+    branch, description = _fetch_github_repo_info(owner=owner, repo_name=repo_name)
+    if extension_dir.exists():
+        # --force reinstall: only remove the previous install once the repo metadata is resolved.
+        shutil.rmtree(extension_dir)
+    manifest = _install_extension(
+        owner=owner, repo_name=repo_name, short_name=short_name, branch=branch, description=description
+    )
+    ext_type = manifest.type.capitalize()
+    out.result(
+        f"{ext_type} extension installed",
+        source=f"{owner}/{repo_name}",
+        command=f"hf {short_name}",
+    )
+    out.hint(f"Run it with: hf {short_name}")
+
+
+@extensions_cli.command(
+    "update",
+    examples=[
+        "hf extensions update",
+        "hf extensions update hf-claude",
+        "hf extensions update alvarobartt/hf-mem",
+    ],
+)
+def extension_update(
+    name: Annotated[
+        str | None,
+        Argument(
+            help=(
+                "Extension to update (with or without `hf-` prefix, optionally as `OWNER/hf-<name>`). "
+                "If omitted, all installed extensions are checked and the outdated ones are updated."
+            ),
+        ),
+    ] = None,
+) -> None:
+    """Update installed extension(s) to their latest version."""
+    if name is not None:
+        manifest = _load_installed_extension_for_update(name)
+        update_status = _update_installed_extension(manifest)
+        match update_status:
+            case _ExtensionUpdateStatus.UPDATED:
+                out.result("Extension updated", name=manifest.short_name, source=manifest.repo_id)
+            case _ExtensionUpdateStatus.UP_TO_DATE:
+                out.result(f"Extension '{manifest.short_name}' is already up to date", name=manifest.short_name)
+            case _ExtensionUpdateStatus.SKIPPED:
+                pass  # warning already emitted by _update_installed_extension
+        return
+
+    manifests = _list_installed_extensions()
+    if not manifests:
+        out.warning("No extensions installed.")
+        out.hint("Install one with: hf extensions install <repo_id>")
+        return
+
+    updated = []
+    up_to_date = []
+    for manifest in manifests:
+        out.log(f"Checking '{manifest.short_name}' ({manifest.repo_id})...")
+        try:
+            update_status = _update_installed_extension(manifest)
+        except Exception as error:
+            # Keep updating the other extensions even if one fails.
+            out.warning(f"Could not update '{manifest.short_name}' ({manifest.repo_id}): {error}. Skipping.")
+            continue
+        match update_status:
+            case _ExtensionUpdateStatus.UPDATED:
+                updated.append(manifest.short_name)
+            case _ExtensionUpdateStatus.UP_TO_DATE:
+                up_to_date.append(manifest.short_name)
+            case _ExtensionUpdateStatus.SKIPPED:
+                pass  # warning already emitted by _update_installed_extension
+    out.result(
+        "Extensions update complete",
+        updated=", ".join(updated) if updated else None,
+        up_to_date=", ".join(up_to_date) if up_to_date else None,
+    )
+
+
+@extensions_cli.command(
+    "exec",
+    context_settings={"allow_extra_args": True, "allow_interspersed_args": False, "ignore_unknown_options": True},
+    examples=[
+        "hf extensions exec claude -- --help",
+        "hf extensions exec claude --model zai-org/GLM-5",
+    ],
+)
+def extension_exec(
+    ctx: click.Context,
+    name: Annotated[
+        str,
+        Argument(help="Extension name (with or without `hf-` prefix)."),
+    ],
+) -> None:
+    """Execute an installed extension."""
+    short_name = _normalize_extension_name(name)
+    executable_path = _resolve_installed_executable_path(short_name)
+
+    if not executable_path.is_file():
+        raise CLIError(f"Extension '{short_name}' is not installed.")
+
+    exit_code = _execute_extension_binary(executable_path=executable_path, args=list(ctx.args))
+    raise click.exceptions.Exit(code=exit_code)
+
+
+@extensions_cli.command("list | ls", examples=["hf extensions list"])
+def extension_list() -> None:
+    """List installed extension commands."""
+    rows = [
+        {
+            "command": f"hf {manifest.short_name}",
+            "source": str(manifest.repo_id),
+            "type": str(manifest.type),
+            "installed": manifest.installed_at.strftime("%Y-%m-%d"),
+            "description": manifest.description,
+        }
+        for manifest in _list_installed_extensions()
+    ]
+    out.table(rows, id_key="command")
+
+
+@extensions_cli.command("search", examples=["hf extensions search"])
+def extension_search() -> None:
+    """Search extensions available on GitHub (tagged with 'hf-extension' topic)."""
+    response = _github_get(
+        "https://api.github.com/search/repositories",
+        params={"q": f"topic:{_EXTENSIONS_GITHUB_TOPIC}", "sort": "stars", "order": "desc", "per_page": 100},
+    )
+    data = response.json()
+
+    installed = {m.short_name for m in _list_installed_extensions()}
+
+    rows = []
+    for repo in data.get("items", []):
+        short_name = repo["name"].removeprefix("hf-")
+        rows.append(
+            {
+                "name": short_name,
+                "repo": repo["full_name"],
+                "stars": repo.get("stargazers_count", 0),
+                "description": repo.get("description") or "",
+                "installed": "yes" if short_name in installed else "",
+            }
+        )
+
+    out.table(rows, id_key="repo")
+
+
+@extensions_cli.command("remove | rm", examples=["hf extensions remove claude"])
+def extension_remove(
+    name: Annotated[
+        str,
+        Argument(help="Extension name to remove (with or without `hf-` prefix)."),
+    ],
+) -> None:
+    """Remove an installed extension."""
+    short_name = _normalize_extension_name(name)
+    extension_dir = _get_extension_dir(short_name)
+
+    if not extension_dir.is_dir():
+        raise CLIError(f"Extension '{short_name}' is not installed.")
+
+    shutil.rmtree(extension_dir)
+    out.result("Extension removed", name=short_name)
+
+
+### HELPER FUNCTIONS
+
+
+def _list_installed_extensions() -> list[ExtensionManifest]:
+    """Return manifests for all validly-installed extensions, sorted by directory name."""
+    root_dir = EXTENSIONS_ROOT.expanduser()
+    if not root_dir.is_dir():
+        return []
+    manifests = []
+    for extension_dir in sorted(root_dir.iterdir()):
+        if not extension_dir.is_dir() or not extension_dir.name.startswith("hf-"):
+            continue
+        try:
+            manifests.append(ExtensionManifest.load(extension_dir))
+        except Exception as e:
+            logger.debug(f"Failed to load manifest for extension '{extension_dir.name}': {e}")
+            continue
+    return manifests
+
+
+def list_installed_extensions_for_help() -> list[tuple[str, str]]:
+    entries = []
+    for manifest in _list_installed_extensions():
+        tag = f"[extension {manifest.repo_id}]"
+        help_text = f"{manifest.description} {tag}" if manifest.description is not None else tag
+        entries.append((manifest.short_name, help_text))
+    return entries
+
+
+def dispatch_unknown_top_level_extension(args: list[str], known_commands: set[str]) -> int | None:
+    if not args:
+        return None
+
+    command_name = args[0]
+    if command_name.startswith("-"):
+        return None
+    all_known = {a.strip() for cmd in known_commands for a in cmd.split("|")}
+    if command_name in all_known:
+        return None
+
+    try:
+        short_name = _validate_extension_short_name(command_name.removeprefix("hf-"), original_input=command_name)
+    except CLIError:
+        return None
+
+    executable_path: Path | None
+    try:
+        executable_path = _resolve_installed_executable_path(short_name)
+    except Exception:
+        executable_path = _auto_install_official_extension(short_name)
+
+    if executable_path is None or not executable_path.is_file():
+        return None
+
+    return _execute_extension_binary(executable_path=executable_path, args=list(args[1:]))
+
+
+def _auto_install_official_extension(short_name: str) -> Path | None:
+    """Try to auto-install huggingface/hf-<name>. Returns executable path or None."""
+    owner, repo_name = DEFAULT_EXTENSION_OWNER, f"hf-{short_name}"
+    if _get_extension_dir(short_name).exists():
+        return None
+
+    try:
+        branch, description = _fetch_github_repo_info(owner=owner, repo_name=repo_name)
+    except Exception:
+        return None
+
+    try:
+        out.confirm(f"'{short_name}' is an official Hugging Face extension ({owner}/{repo_name}). Install it?")
+    except ConfirmationError:
+        return None
+    try:
+        manifest = _install_extension(
+            owner=owner, repo_name=repo_name, short_name=short_name, branch=branch, description=description
+        )
+        return Path(manifest.executable_path).expanduser()
+    except Exception:
+        return None
+
+
+def _load_installed_extension_for_update(name: str) -> ExtensionManifest:
+    short_name = _normalize_extension_name(name)
+    extension_dir = _get_extension_dir(short_name)
+    if not extension_dir.is_dir():
+        owner, _, _ = name.strip().rpartition("/")
+        install_target = f"{owner}/hf-{short_name}" if owner else f"hf-{short_name}"
+        raise CLIError(
+            f"Extension '{short_name}' is not installed. Install it first with: hf extensions install {install_target}"
+        )
+    return ExtensionManifest.load(extension_dir)
+
+
+def _update_installed_extension(manifest: ExtensionManifest) -> _ExtensionUpdateStatus:
+    owner, repo_name, short_name = manifest.owner, manifest.repo, manifest.short_name
+
+    try:
+        branch, description = _fetch_github_repo_info(owner=owner, repo_name=repo_name)
+    except Exception as error:
+        out.warning(f"Could not check updates for '{short_name}' ({owner}/{repo_name}): {error}. Skipping.")
+        return _ExtensionUpdateStatus.SKIPPED
+
+    latest_sha = _fetch_latest_commit_sha(owner=owner, repo_name=repo_name, branch=branch, warn=False)
+    if latest_sha is None:
+        out.warning(
+            f"Could not check updates for '{short_name}' ({owner}/{repo_name}): GitHub is unreachable. Skipping."
+        )
+        return _ExtensionUpdateStatus.SKIPPED
+
+    if latest_sha == manifest.commit_sha:
+        return _ExtensionUpdateStatus.UP_TO_DATE
+
+    _install_extension(
+        owner=owner,
+        repo_name=repo_name,
+        short_name=short_name,
+        branch=branch,
+        description=description,
+        commit_sha=latest_sha,
+    )
+    return _ExtensionUpdateStatus.UPDATED
+
+
+def _install_extension(
+    *,
+    owner: str,
+    repo_name: str,
+    short_name: str,
+    branch: str,
+    description: str | None = None,
+    commit_sha: str | None = None,
+) -> ExtensionManifest:
+    """Fetch and install an extension (binary or Python package), then persist its manifest.
+
+    Installs in place: an existing install is overwritten without being removed first, so a failed
+    update keeps the previous version working. A failed fresh install is cleaned up entirely.
+    """
+    extension_dir = _get_extension_dir(short_name)
+    fresh_install = not extension_dir.exists()
+    installed = False
+    try:
+        try:
+            binary = _fetch_remote_binary(owner=owner, repo_name=repo_name, branch=branch, short_name=short_name)
+        except Exception:
+            binary = None
+
+        if binary is not None:
+            executable_path = _install_binary_extension(
+                extension_dir=extension_dir, short_name=short_name, binary=binary
+            )
+        else:
+            executable_path = _install_python_extension(
+                extension_dir=extension_dir, owner=owner, repo_name=repo_name, short_name=short_name, branch=branch
+            )
+
+        manifest = ExtensionManifest(
+            owner=owner,
+            repo=repo_name,
+            repo_id=f"{owner}/{repo_name}",
+            short_name=short_name,
+            executable_path=str(executable_path),
+            type="binary" if binary is not None else "python",
+            installed_at=datetime.now(timezone.utc),
+            description=_try_fetch_remote_description(
+                owner=owner, repo_name=repo_name, branch=branch, candidate_description=description
+            ),
+            commit_sha=commit_sha or _fetch_latest_commit_sha(owner=owner, repo_name=repo_name, branch=branch),
+        )
+        manifest.save(extension_dir)
+        installed = True
+        return manifest
+    except CLIError:
+        raise
+    except subprocess.TimeoutExpired as e:
+        raise CLIExtensionInstallError(
+            f"Pip install timed out after {_EXTENSIONS_PIP_INSTALL_TIMEOUT}s for '{owner}/{repo_name}'. "
+            "See pip output above for details."
+        ) from e
+    except subprocess.CalledProcessError as e:
+        raise CLIExtensionInstallError(
+            f"Failed to install pip package from '{owner}/{repo_name}' (exit code {e.returncode}). "
+            "See pip output above for details."
+        ) from e
+    except Exception as e:
+        raise CLIExtensionInstallError(f"Failed to install extension from '{owner}/{repo_name}': {e}") from e
+    finally:
+        if not installed and fresh_install:
+            shutil.rmtree(extension_dir, ignore_errors=True)
+
+
+def _fetch_latest_commit_sha(*, owner: str, repo_name: str, branch: str, warn: bool = True) -> str | None:
+    """Best-effort fetch of the latest commit SHA for a branch, used to detect available updates."""
+    try:
+        response = _github_get(
+            f"https://api.github.com/repos/{owner}/{repo_name}/commits/{branch}",
+            headers={"Accept": "application/vnd.github.sha"},
+        )
+        return response.text.strip() or None
+    except Exception as error:
+        if warn:
+            out.warning(f"Could not fetch latest commit SHA for '{repo_name}' ({owner}/{repo_name}): {error}")
+        return None
+
+
+def _fetch_remote_binary(*, owner: str, repo_name: str, branch: str, short_name: str) -> bytes:
+    executable_name = _get_executable_name(short_name)
+    raw_url = f"https://raw.githubusercontent.com/{owner}/{repo_name}/refs/heads/{branch}/{executable_name}"
+    response = _github_get(raw_url)
+    return response.content
+
+
+def _install_binary_extension(*, extension_dir: Path, short_name: str, binary: bytes) -> Path:
+    extension_dir.mkdir(parents=True, exist_ok=True)
+    executable_path = extension_dir / _get_executable_name(short_name)
+    executable_path.write_bytes(binary)
+
+    if os.name != "nt":
+        os.chmod(executable_path, 0o755)
+
+    return executable_path
+
+
+def _install_python_extension(
+    *, extension_dir: Path, owner: str, repo_name: str, short_name: str, branch: str
+) -> Path:
+    source_url = f"https://github.com/{owner}/{repo_name}/archive/refs/heads/{branch}.zip"
+    venv_dir = extension_dir / "venv"
+    venv_python = _get_venv_bin_path(venv_dir, "python.exe" if os.name == "nt" else "python")
+    uv_path = shutil.which("uv")
+
+    status = out.status()
+    if not venv_python.is_file():
+        status.update(f"Creating virtual environment in {venv_dir}")
+        extension_dir.mkdir(parents=True, exist_ok=True)
+        if uv_path:
+            subprocess.run([uv_path, "venv", str(venv_dir)], check=True)
+        else:
+            venv.EnvBuilder(with_pip=True).create(str(venv_dir))
+        status.done(f"Virtual environment created in {venv_dir}")
+
+    status.update(f"Installing package from {source_url}")
+    if uv_path:
+        # --reinstall: the source URL is the same for every commit, so cached data must be refreshed.
+        install_cmd = [uv_path, "pip", "install", "--reinstall", "--python", str(venv_python), source_url]
+    else:
+        install_cmd = [
+            str(venv_python),
+            "-m",
+            "pip",
+            "install",
+            "--disable-pip-version-check",
+            "--no-input",
+            "--force-reinstall",
+            source_url,
+        ]
+    subprocess.run(install_cmd, check=True, timeout=_EXTENSIONS_PIP_INSTALL_TIMEOUT)
+    status.done(f"Package installed from {source_url}")
+
+    executable_name = _get_executable_name(short_name)
+    venv_executable = _get_venv_bin_path(venv_dir, executable_name)
+    if not venv_executable.is_file():
+        raise CLIError(
+            f"Installed package from '{owner}/{repo_name}' does not expose the required console script "
+            f"'{executable_name}'."
+        )
+    return venv_executable.resolve()
+
+
+def _try_fetch_remote_description(
+    owner: str, repo_name: str, branch: str, candidate_description: str | None
+) -> str | None:
+    """Try to fetch project description either from:
+    - manifest.json
+    - pyproject.toml
+
+    Only best effort, no error handling.
+    """
+    base = f"https://raw.githubusercontent.com/{owner}/{repo_name}/refs/heads/{branch}"
+
+    # from manifest.json
+    try:
+        response = _github_get(f"{base}/{MANIFEST_FILENAME}")
+        description = response.json().get("description")
+        if isinstance(description, str):
+            return description
+    except Exception:
+        pass
+
+    # from pyproject.toml
+    try:
+        response = _github_get(f"{base}/pyproject.toml")
+
+        # Weak parser but ok for "best effort"
+        for line in response.text.splitlines():
+            line = line.strip()
+            if line.startswith("description"):
+                _, _, value = line.partition("=")
+                return value.strip().strip("\"'")
+    except Exception:
+        pass
+
+    # fallback to value fetched from GH API directly
+    return candidate_description
+
+
+def _get_extension_dir(short_name: str) -> Path:
+    # Callers validate at the parse boundary already; re-validate here as defense-in-depth since
+    # this path is rmtree'd on removal.
+    _validate_extension_short_name(short_name, original_input=short_name)
+    return EXTENSIONS_ROOT.expanduser() / f"hf-{short_name}"
+
+
+def _github_get(url: str, *, params: dict | None = None, headers: dict | None = None):
+    """Perform a GitHub GET request.
+
+    Shared by every GitHub/Raw fetch in this module so the timeout and redirect policy are shared.
+    """
+    response = get_session().get(
+        url,
+        params=params,
+        headers=headers,
+        follow_redirects=True,
+        timeout=_EXTENSIONS_DOWNLOAD_TIMEOUT,
+    )
+    response.raise_for_status()
+    return response
+
+
+def _fetch_github_repo_info(*, owner: str, repo_name: str) -> tuple[str, str | None]:
+    """Fetch `default_branch` + `description` for a GitHub repo from `GET /repos/{owner}/{repo}`."""
+    response = _github_get(f"https://api.github.com/repos/{owner}/{repo_name}")
+    data = response.json()
+    return data["default_branch"], data.get("description")
+
+
+def _get_executable_name(short_name: str) -> str:
+    name = f"hf-{short_name}"
+    if os.name == "nt":
+        name += ".exe"
+    return name
+
+
+def _resolve_installed_executable_path(short_name: str) -> Path:
+    extension_dir = _get_extension_dir(short_name)
+    manifest = ExtensionManifest.load(extension_dir)
+    return Path(manifest.executable_path).expanduser()
+
+
+def _get_venv_bin_path(venv_dir: Path, executable_name: str) -> Path:
+    if os.name == "nt":
+        return venv_dir / "Scripts" / executable_name
+    return venv_dir / "bin" / executable_name
+
+
+_ALLOWED_EXTENSION_NAME = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*$")
+
+
+def _validate_extension_short_name(short_name: str, *, original_input: str) -> str:
+    name = short_name.strip()
+    if not name:
+        raise CLIError("Extension name cannot be empty.")
+    if any(sep in name for sep in ("/", "\\")):
+        raise CLIError(f"Invalid extension name '{original_input}'.")
+    if ".." in name or ":" in name:
+        raise CLIError(f"Invalid extension name '{original_input}'.")
+    if not _ALLOWED_EXTENSION_NAME.fullmatch(name):
+        raise CLIError(
+            f"Invalid extension name '{original_input}'. Allowed characters: letters, digits, '.', '_' and '-'."
+        )
+    return name
+
+
+def _normalize_repo_id(repo_id: str) -> tuple[str, str, str]:
+    if "://" in repo_id:
+        raise CLIError("Only GitHub repositories in `[OWNER/]hf-<name>` format are supported.")
+
+    parts = repo_id.split("/")
+    if len(parts) == 1:
+        owner = DEFAULT_EXTENSION_OWNER
+        repo_name = parts[0]
+    elif len(parts) == 2 and all(parts):
+        owner, repo_name = parts
+    else:
+        raise CLIError(f"Expected `[OWNER/]REPO` format, got '{repo_id}'.")
+
+    if not repo_name.startswith("hf-"):
+        raise CLIError(f"Extension repository name must start with 'hf-', got '{repo_name}'.")
+
+    short_name = repo_name.removeprefix("hf-")
+    if not short_name:
+        raise CLIError("Invalid extension repository name 'hf-'.")
+    _validate_extension_short_name(short_name, original_input=repo_id)
+
+    return owner, repo_name, short_name
+
+
+def _normalize_extension_name(name: str) -> str:
+    repo_name = name.strip().rsplit("/", 1)[-1]
+    return _validate_extension_short_name(repo_name.removeprefix("hf-"), original_input=name)
+
+
+def _execute_extension_binary(executable_path: Path, args: list[str]) -> int:
+    try:
+        return subprocess.call([str(executable_path)] + args)
+    except OSError as e:
+        if os.name == "nt" or e.errno != errno.ENOEXEC:
+            raise
+        return subprocess.call(["sh", str(executable_path)] + args)

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/hf.py

@@ -0,0 +1,142 @@
+# 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.
+
+import os
+import sys
+import traceback
+from typing import Annotated
+
+import click
+
+from huggingface_hub import __version__, constants
+from huggingface_hub.cli._cli_utils import check_cli_update, fallback_typer_group_factory, typer_factory
+from huggingface_hub.cli._cp import CP_EXAMPLES, make_cp
+from huggingface_hub.cli._errors import format_known_exception
+from huggingface_hub.cli._output import out
+from huggingface_hub.cli.auth import auth_cli
+from huggingface_hub.cli.buckets import buckets_cli, sync
+from huggingface_hub.cli.cache import cache_cli
+from huggingface_hub.cli.collections import collections_cli
+from huggingface_hub.cli.datasets import datasets_cli
+from huggingface_hub.cli.discussions import discussions_cli
+from huggingface_hub.cli.download import DOWNLOAD_EXAMPLES, download
+from huggingface_hub.cli.extensions import (
+    dispatch_unknown_top_level_extension,
+    extensions_cli,
+    list_installed_extensions_for_help,
+)
+from huggingface_hub.cli.inference_endpoints import ie_cli
+from huggingface_hub.cli.jobs import jobs_cli
+from huggingface_hub.cli.lfs import lfs_enable_largefiles, lfs_multipart_upload
+from huggingface_hub.cli.models import models_cli
+from huggingface_hub.cli.papers import papers_cli
+from huggingface_hub.cli.repo_files import repo_files_cli
+from huggingface_hub.cli.repos import repos_cli
+from huggingface_hub.cli.sandbox import sandbox_cli
+from huggingface_hub.cli.skills import skills_cli
+from huggingface_hub.cli.spaces import spaces_cli
+from huggingface_hub.cli.system import env, update, version
+from huggingface_hub.cli.upload import UPLOAD_EXAMPLES, upload
+from huggingface_hub.cli.upload_large_folder import UPLOAD_LARGE_FOLDER_EXAMPLES, upload_large_folder
+from huggingface_hub.cli.webhooks import webhooks_cli
+from huggingface_hub.utils import logging
+
+from ._completion import _COMPLETE_VAR, InstallCompletionOpt, ShowCompletionOpt
+from ._framework import Option
+
+
+app = typer_factory(
+    help="Hugging Face Hub CLI",
+    cls=fallback_typer_group_factory(
+        dispatch_unknown_top_level_extension,
+        extra_commands_provider=list_installed_extensions_for_help,
+    ),
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        print(__version__)
+        raise click.exceptions.Exit()
+
+
+@app.group_callback(invoke_without_command=True)
+def app_callback(
+    version: Annotated[
+        bool | None, Option("-v", "--version", callback=_version_callback, is_eager=True, hidden=True)
+    ] = None,
+    install_completion: InstallCompletionOpt = False,
+    show_completion: ShowCompletionOpt = False,
+) -> None:
+    pass
+
+
+# top level single commands (defined in their respective files)
+app.command(examples=CP_EXAMPLES)(make_cp())
+app.command()(sync)
+app.command(examples=DOWNLOAD_EXAMPLES)(download)
+app.command(examples=UPLOAD_EXAMPLES)(upload)
+app.command(examples=UPLOAD_LARGE_FOLDER_EXAMPLES)(upload_large_folder)
+
+app.command(topic="help")(env)
+app.command(topic="help")(update)
+app.command(topic="help")(version)
+
+app.command(hidden=True)(lfs_enable_largefiles)
+app.command(hidden=True)(lfs_multipart_upload)
+
+# command groups
+app.add_group(auth_cli, name="auth")
+app.add_group(buckets_cli, name="buckets")
+app.add_group(cache_cli, name="cache")
+app.add_group(collections_cli, name="collections")
+app.add_group(datasets_cli, name="datasets")
+app.add_group(discussions_cli, name="discussions")
+app.add_group(jobs_cli, name="jobs")
+app.add_group(models_cli, name="models")
+app.add_group(papers_cli, name="papers")
+app.add_group(repos_cli, name="repos | repo")
+app.add_group(repo_files_cli, name="repo-files", hidden=True)
+app.add_group(sandbox_cli, name="sandbox")
+app.add_group(skills_cli, name="skills")
+app.add_group(spaces_cli, name="spaces")
+app.add_group(webhooks_cli, name="webhooks")
+app.add_group(ie_cli, name="endpoints")
+app.add_group(extensions_cli, name="extensions | ext")
+
+
+def main():
+    # Shell-completion requests must stay fast and emit nothing but candidates:
+    # skip the startup work and let click handle the env var inside `app()`.
+    if _COMPLETE_VAR not in os.environ:
+        if not constants.HF_DEBUG:
+            logging.set_verbosity_info()
+        check_cli_update("huggingface_hub")
+
+    try:
+        app()
+    except Exception as e:
+        message = format_known_exception(e)
+        if message:
+            out.error(message)
+            if constants.HF_DEBUG:
+                traceback.print_exc()
+            else:
+                out.hint("set HF_DEBUG=1 as environment variable for full traceback.")
+            sys.exit(1)
+        raise
+
+
+if __name__ == "__main__":
+    main()

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/inference_endpoints.py

@@ -0,0 +1,535 @@
+"""CLI commands for Hugging Face Inference Endpoints."""
+
+import shlex
+from typing import Annotated
+
+import click
+
+from huggingface_hub._inference_endpoints import InferenceEndpointScalingMetric, InferenceEndpointType
+from huggingface_hub.errors import CLIError, HfHubHTTPError
+
+from ._cli_utils import (
+    EnvFileOpt,
+    EnvOpt,
+    RevisionOpt,
+    SecretsFileOpt,
+    SecretsOpt,
+    SoftChoice,
+    TokenOpt,
+    get_hf_api,
+    parse_env_map,
+    typer_factory,
+)
+from ._framework import Argument, Option
+from ._output import out
+
+
+ie_cli = typer_factory(help="Manage Hugging Face Inference Endpoints.")
+
+catalog_app = typer_factory(help="Interact with the Inference Endpoints catalog.")
+
+
+NameArg = Annotated[
+    str,
+    Argument(help="Endpoint name."),
+]
+NameOpt = Annotated[
+    str | None,
+    Option(help="Endpoint name."),
+]
+
+NamespaceOpt = Annotated[
+    str | None,
+    Option(
+        help="The namespace associated with the Inference Endpoint. Defaults to the current user's namespace.",
+    ),
+]
+
+
+@ie_cli.command("list | ls", examples=["hf endpoints ls", "hf endpoints ls --namespace my-org"])
+def ls(
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Lists all Inference Endpoints for the given namespace."""
+    api = get_hf_api(token=token)
+    try:
+        endpoints = api.list_inference_endpoints(namespace=namespace, token=token)
+    except HfHubHTTPError as error:
+        out.error(f"Listing failed: {error}")
+        raise click.exceptions.Exit(code=error.response.status_code) from error
+
+    results = []
+    for endpoint in endpoints:
+        raw = endpoint.raw
+        status = raw.get("status", {})
+        model = raw.get("model", {})
+        compute = raw.get("compute", {})
+        provider = raw.get("provider", {})
+        results.append(
+            {
+                "name": raw.get("name", ""),
+                "model": model.get("repository", "") if isinstance(model, dict) else "",
+                "status": status.get("state", "") if isinstance(status, dict) else "",
+                "task": model.get("task", "") if isinstance(model, dict) else "",
+                "framework": model.get("framework", "") if isinstance(model, dict) else "",
+                "instance": compute.get("instanceType", "") if isinstance(compute, dict) else "",
+                "vendor": provider.get("vendor", "") if isinstance(provider, dict) else "",
+                "region": provider.get("region", "") if isinstance(provider, dict) else "",
+            }
+        )
+    out.table(results, id_key="name")
+
+
+@ie_cli.command(name="deploy", examples=["hf endpoints deploy my-endpoint --repo gpt2 --framework pytorch ..."])
+def deploy(
+    name: NameArg,
+    repo: Annotated[
+        str,
+        Option(
+            help="The name of the model repository associated with the Inference Endpoint (e.g. 'openai/gpt-oss-120b').",
+        ),
+    ],
+    framework: Annotated[
+        str,
+        Option(
+            help="The machine learning framework used for the model (e.g. 'vllm').",
+        ),
+    ],
+    accelerator: Annotated[
+        str,
+        Option(
+            help="The hardware accelerator to be used for inference (e.g. 'cpu').",
+        ),
+    ],
+    instance_size: Annotated[
+        str,
+        Option(
+            help="The size or type of the instance to be used for hosting the model (e.g. 'x4').",
+        ),
+    ],
+    instance_type: Annotated[
+        str,
+        Option(
+            help="The cloud instance type where the Inference Endpoint will be deployed (e.g. 'intel-icl').",
+        ),
+    ],
+    region: Annotated[
+        str,
+        Option(
+            help="The cloud region in which the Inference Endpoint will be created (e.g. 'us-east-1').",
+        ),
+    ],
+    vendor: Annotated[
+        str,
+        Option(
+            help="The cloud provider or vendor where the Inference Endpoint will be hosted (e.g. 'aws').",
+        ),
+    ],
+    *,
+    namespace: NamespaceOpt = None,
+    task: Annotated[
+        str | None,
+        Option(
+            help="The task on which to deploy the model (e.g. 'text-classification').",
+        ),
+    ] = None,
+    token: TokenOpt = None,
+    min_replica: Annotated[
+        int,
+        Option(
+            help="The minimum number of replicas (instances) to keep running for the Inference Endpoint.",
+        ),
+    ] = 1,
+    max_replica: Annotated[
+        int,
+        Option(
+            help="The maximum number of replicas (instances) to scale to for the Inference Endpoint.",
+        ),
+    ] = 1,
+    scale_to_zero_timeout: Annotated[
+        int | None,
+        Option(
+            help="The duration in minutes before an inactive endpoint is scaled to zero.",
+        ),
+    ] = None,
+    scaling_metric: Annotated[
+        InferenceEndpointScalingMetric | None,
+        Option(
+            help="The metric reference for scaling.",
+        ),
+    ] = None,
+    scaling_threshold: Annotated[
+        float | None,
+        Option(
+            help="The scaling metric threshold used to trigger a scale up. Ignored when scaling metric is not provided.",
+        ),
+    ] = None,
+    revision: RevisionOpt = None,
+    custom_image: Annotated[
+        str | None,
+        Option(
+            "--custom-image",
+            help="Docker image URL for a custom container (e.g. 'nexagi/sglang:v0.5.12'). Requires '--framework custom'.",
+        ),
+    ] = None,
+    health_route: Annotated[
+        str | None,
+        Option(
+            help="Health check route exposed by the custom container (e.g. '/health'). Requires --custom-image.",
+        ),
+    ] = None,
+    port: Annotated[
+        int | None,
+        Option(
+            help="Port the custom container listens on (e.g. 30000). Requires --custom-image.",
+        ),
+    ] = None,
+    container_command: Annotated[
+        str | None,
+        Option(
+            "--container-command",
+            help=(
+                "Override the container entrypoint, as a quoted string split into tokens "
+                '(e.g. "python -m sglang.launch_server"). Requires --custom-image.'
+            ),
+        ),
+    ] = None,
+    container_args: Annotated[
+        str | None,
+        Option(
+            "--container-args",
+            help=(
+                "Arguments appended to the container entrypoint, as a quoted string split into tokens "
+                '(e.g. "--tp 8 --reasoning-parser qwen3"). Requires --custom-image.'
+            ),
+        ),
+    ] = None,
+    env: EnvOpt = None,
+    env_file: EnvFileOpt = None,
+    secrets: SecretsOpt = None,
+    secrets_file: SecretsFileOpt = None,
+    endpoint_type: Annotated[
+        str | None,
+        Option(
+            "--type",
+            click_type=SoftChoice(InferenceEndpointType),
+            help="Endpoint access type. Defaults to 'authenticated' (token-gated, publicly reachable).",
+        ),
+    ] = None,
+) -> None:
+    """Deploy an Inference Endpoint from a Hub repository."""
+    # Custom-container knobs only make sense alongside a custom image.
+    if custom_image is None and (health_route is not None or port is not None or container_command or container_args):
+        raise CLIError("--health-route, --port, --container-command and --container-args require --custom-image.")
+    custom_image_dict: dict | None = None
+    if custom_image is not None:
+        custom_image_dict = {"url": custom_image}
+        if health_route is not None:
+            custom_image_dict["healthRoute"] = health_route
+        if port is not None:
+            custom_image_dict["port"] = port
+
+    env_map = {key: value or "" for key, value in parse_env_map(env, env_file).items()}
+    secrets_map = {key: value or "" for key, value in parse_env_map(secrets, secrets_file).items()}
+
+    # Only forward the values the user actually set and let `create_inference_endpoint` own the defaults.
+    params: dict = {}
+    if endpoint_type is not None:
+        params["type"] = endpoint_type
+    if custom_image_dict is not None:
+        params["custom_image"] = custom_image_dict
+    if container_command:
+        params["container_command"] = shlex.split(container_command)
+    if container_args:
+        params["container_args"] = shlex.split(container_args)
+    if env_map:
+        params["env"] = env_map
+    if secrets_map:
+        params["secrets"] = secrets_map
+
+    api = get_hf_api(token=token)
+    endpoint = api.create_inference_endpoint(
+        name=name,
+        repository=repo,
+        framework=framework,
+        accelerator=accelerator,
+        instance_size=instance_size,
+        instance_type=instance_type,
+        region=region,
+        vendor=vendor,
+        namespace=namespace,
+        task=task,
+        token=token,
+        min_replica=min_replica,
+        max_replica=max_replica,
+        scaling_metric=scaling_metric,
+        scaling_threshold=scaling_threshold,
+        scale_to_zero_timeout=scale_to_zero_timeout,
+        revision=revision,
+        **params,
+    )
+    out.dict(endpoint.raw)
+    out.hint(f"Use 'hf endpoints describe {name}' to check the deployment status.")
+
+
+@catalog_app.command(name="deploy", examples=["hf endpoints catalog deploy --repo meta-llama/Llama-3.2-1B-Instruct"])
+def deploy_from_catalog(
+    repo: Annotated[
+        str,
+        Option(
+            help="The name of the model repository associated with the Inference Endpoint (e.g. 'openai/gpt-oss-120b').",
+        ),
+    ],
+    name: NameOpt = None,
+    accelerator: Annotated[
+        str | None,
+        Option(
+            help="The hardware accelerator to be used for inference (e.g. 'cpu', 'gpu', 'neuron').",
+        ),
+    ] = None,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Deploy an Inference Endpoint from the Model Catalog."""
+    api = get_hf_api(token=token)
+    try:
+        endpoint = api.create_inference_endpoint_from_catalog(
+            repo_id=repo,
+            name=name,
+            accelerator=accelerator,
+            namespace=namespace,
+            token=token,
+        )
+    except HfHubHTTPError as error:
+        out.error(f"Deployment failed: {error}")
+        raise click.exceptions.Exit(code=error.response.status_code) from error
+
+    out.dict(endpoint.raw)
+
+
+def list_catalog(
+    token: TokenOpt = None,
+) -> None:
+    """List available Catalog models."""
+    api = get_hf_api(token=token)
+    try:
+        models = api.list_inference_catalog(token=token)
+    except HfHubHTTPError as error:
+        out.error(f"Catalog fetch failed: {error}")
+        raise click.exceptions.Exit(code=error.response.status_code) from error
+
+    out.dict({"models": models})
+
+
+catalog_app.command(name="list | ls", examples=["hf endpoints catalog ls"])(list_catalog)
+ie_cli.command(name="list-catalog", hidden=True)(list_catalog)
+
+
+ie_cli.add_group(catalog_app, name="catalog")
+
+
+@ie_cli.command(examples=["hf endpoints describe my-endpoint"])
+def describe(
+    name: NameArg,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Get information about an existing endpoint."""
+    api = get_hf_api(token=token)
+    try:
+        endpoint = api.get_inference_endpoint(name=name, namespace=namespace, token=token)
+    except HfHubHTTPError as error:
+        out.error(f"Fetch failed: {error}")
+        raise click.exceptions.Exit(code=error.response.status_code) from error
+
+    out.dict(endpoint.raw)
+
+
+@ie_cli.command(examples=["hf endpoints update my-endpoint --min-replica 2"])
+def update(
+    name: NameArg,
+    namespace: NamespaceOpt = None,
+    repo: Annotated[
+        str | None,
+        Option(
+            help="The name of the model repository associated with the Inference Endpoint (e.g. 'openai/gpt-oss-120b').",
+        ),
+    ] = None,
+    accelerator: Annotated[
+        str | None,
+        Option(
+            help="The hardware accelerator to be used for inference (e.g. 'cpu').",
+        ),
+    ] = None,
+    instance_size: Annotated[
+        str | None,
+        Option(
+            help="The size or type of the instance to be used for hosting the model (e.g. 'x4').",
+        ),
+    ] = None,
+    instance_type: Annotated[
+        str | None,
+        Option(
+            help="The cloud instance type where the Inference Endpoint will be deployed (e.g. 'intel-icl').",
+        ),
+    ] = None,
+    framework: Annotated[
+        str | None,
+        Option(
+            help="The machine learning framework used for the model (e.g. 'custom').",
+        ),
+    ] = None,
+    revision: Annotated[
+        str | None,
+        Option(
+            help="The specific model revision to deploy on the Inference Endpoint (e.g. '6c0e6080953db56375760c0471a8c5f2929baf11').",
+        ),
+    ] = None,
+    task: Annotated[
+        str | None,
+        Option(
+            help="The task on which to deploy the model (e.g. 'text-classification').",
+        ),
+    ] = None,
+    min_replica: Annotated[
+        int | None,
+        Option(
+            help="The minimum number of replicas (instances) to keep running for the Inference Endpoint.",
+        ),
+    ] = None,
+    max_replica: Annotated[
+        int | None,
+        Option(
+            help="The maximum number of replicas (instances) to scale to for the Inference Endpoint.",
+        ),
+    ] = None,
+    scale_to_zero_timeout: Annotated[
+        int | None,
+        Option(
+            help="The duration in minutes before an inactive endpoint is scaled to zero.",
+        ),
+    ] = None,
+    scaling_metric: Annotated[
+        InferenceEndpointScalingMetric | None,
+        Option(
+            help="The metric reference for scaling.",
+        ),
+    ] = None,
+    scaling_threshold: Annotated[
+        float | None,
+        Option(
+            help="The scaling metric threshold used to trigger a scale up. Ignored when scaling metric is not provided.",
+        ),
+    ] = None,
+    token: TokenOpt = None,
+) -> None:
+    """Update an existing endpoint."""
+    api = get_hf_api(token=token)
+    try:
+        endpoint = api.update_inference_endpoint(
+            name=name,
+            namespace=namespace,
+            repository=repo,
+            framework=framework,
+            revision=revision,
+            task=task,
+            accelerator=accelerator,
+            instance_size=instance_size,
+            instance_type=instance_type,
+            min_replica=min_replica,
+            max_replica=max_replica,
+            scale_to_zero_timeout=scale_to_zero_timeout,
+            scaling_metric=scaling_metric,
+            scaling_threshold=scaling_threshold,
+            token=token,
+        )
+    except HfHubHTTPError as error:
+        out.error(f"Update failed: {error}")
+        raise click.exceptions.Exit(code=error.response.status_code) from error
+    out.dict(endpoint.raw)
+
+
+@ie_cli.command(examples=["hf endpoints delete my-endpoint"])
+def delete(
+    name: NameArg,
+    namespace: NamespaceOpt = None,
+    yes: Annotated[
+        bool,
+        Option("--yes", help="Skip confirmation prompts."),
+    ] = False,
+    token: TokenOpt = None,
+) -> None:
+    """Delete an Inference Endpoint permanently."""
+    out.confirm(f"Delete endpoint '{name}'?", yes=yes)
+
+    api = get_hf_api(token=token)
+    try:
+        api.delete_inference_endpoint(name=name, namespace=namespace, token=token)
+    except HfHubHTTPError as error:
+        out.error(f"Delete failed: {error}")
+        raise click.exceptions.Exit(code=error.response.status_code) from error
+
+    out.result(f"Deleted '{name}'.", name=name)
+
+
+@ie_cli.command(examples=["hf endpoints pause my-endpoint"])
+def pause(
+    name: NameArg,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Pause an Inference Endpoint."""
+    api = get_hf_api(token=token)
+    try:
+        endpoint = api.pause_inference_endpoint(name=name, namespace=namespace, token=token)
+    except HfHubHTTPError as error:
+        out.error(f"Pause failed: {error}")
+        raise click.exceptions.Exit(code=error.response.status_code) from error
+
+    out.dict(endpoint.raw)
+
+
+@ie_cli.command(examples=["hf endpoints resume my-endpoint"])
+def resume(
+    name: NameArg,
+    namespace: NamespaceOpt = None,
+    fail_if_already_running: Annotated[
+        bool,
+        Option(
+            "--fail-if-already-running",
+            help="If `True`, the method will raise an error if the Inference Endpoint is already running.",
+        ),
+    ] = False,
+    token: TokenOpt = None,
+) -> None:
+    """Resume an Inference Endpoint."""
+    api = get_hf_api(token=token)
+    try:
+        endpoint = api.resume_inference_endpoint(
+            name=name,
+            namespace=namespace,
+            token=token,
+            running_ok=not fail_if_already_running,
+        )
+    except HfHubHTTPError as error:
+        out.error(f"Resume failed: {error}")
+        raise click.exceptions.Exit(code=error.response.status_code) from error
+    out.dict(endpoint.raw)
+
+
+@ie_cli.command(examples=["hf endpoints scale-to-zero my-endpoint"])
+def scale_to_zero(
+    name: NameArg,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Scale an Inference Endpoint to zero."""
+    api = get_hf_api(token=token)
+    try:
+        endpoint = api.scale_to_zero_inference_endpoint(name=name, namespace=namespace, token=token)
+    except HfHubHTTPError as error:
+        out.error(f"Scale To Zero failed: {error}")
+        raise click.exceptions.Exit(code=error.response.status_code) from error
+
+    out.dict(endpoint.raw)

.cache/uv/archive-v0/LUZqsK8zwmHIcO7YhH0I8/huggingface_hub/cli/jobs.py

@@ -0,0 +1,1335 @@
+# 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.
+"""Contains commands to interact with jobs on the Hugging Face Hub."""
+
+import itertools
+import multiprocessing
+import multiprocessing.pool
+import shutil
+import time
+from collections.abc import Callable, Iterable
+from fnmatch import fnmatch
+from pathlib import Path
+from queue import Empty, Queue
+from typing import Annotated, Any, TypeVar
+from urllib.parse import urlsplit
+
+from huggingface_hub import HfApi, JobHardware, JobInfo, JobStage, Volume, constants
+from huggingface_hub._jobs_api import TERMINAL_JOB_STAGES
+from huggingface_hub.errors import CLIError
+from huggingface_hub.utils import logging
+from huggingface_hub.utils._cache_manager import _format_size
+from huggingface_hub.utils._hf_uris import _split_mount
+from huggingface_hub.utils._parsing import format_duration, parse_duration
+
+from ._cli_utils import (
+    EnvFileOpt,
+    EnvOpt,
+    SecretsFileOpt,
+    SecretsOpt,
+    SoftChoice,
+    SshDryRunOpt,
+    SshIdentityFileOpt,
+    TokenOpt,
+    exec_ssh,
+    get_hf_api,
+    parse_env_map,
+    parse_volumes,
+    typer_factory,
+)
+from ._framework import Argument, Option
+from ._output import _dataclass_to_dict, out
+
+
+logger = logging.get_logger(__name__)
+
+
+def _parse_namespace_from_job_id(job_id: str, namespace: str | None) -> tuple[str, str | None]:
+    """Extract namespace from job_id if provided in 'namespace/job_id' format.
+
+    Allows users to pass job IDs copied from the Hub UI (e.g. 'username/job_id')
+    instead of only bare job IDs. If the namespace is also provided explicitly via
+    --namespace and conflicts, a CLIError is raised.
+    """
+    if not job_id:
+        raise CLIError("Job ID cannot be empty.")
+
+    if job_id.count("/") > 1:
+        raise CLIError(f"Job ID must be in the form 'job_id' or 'namespace/job_id': '{job_id}'.")
+
+    if "/" not in job_id:
+        return job_id, namespace
+
+    extracted_namespace, parsed_job_id = job_id.split("/", 1)
+    if not extracted_namespace or not parsed_job_id:
+        raise CLIError(f"Job ID must be in the form 'job_id' or 'namespace/job_id': '{job_id}'.")
+
+    if namespace is not None and namespace != extracted_namespace:
+        raise CLIError(
+            f"Conflicting namespace: got --namespace='{namespace}' but job ID implies namespace='{extracted_namespace}'"
+        )
+
+    return parsed_job_id, extracted_namespace
+
+
+def _parse_and_sync_job_volumes(
+    volumes: list[str] | None, *, api: HfApi, namespace: str | None
+) -> list[Volume] | None:
+    """Parse `-v` specs for Jobs commands.
+
+    Same as [`parse_volumes`] but the source side can also be a local directory: it is synced to a
+    bucket via [`HfApi.sync_job_volume`] and the resulting bucket subfolder is mounted (read-only
+    unless ':rw' is specified).
+    """
+    if not volumes:
+        return None
+
+    result: list[Volume] = []
+    for raw_spec in volumes:
+        if raw_spec.startswith(constants.HF_PROTOCOL):
+            result.extend(parse_volumes([raw_spec]) or [])
+            continue
+
+        # Not a 'hf://' URI: treat the source as a local directory.
+        source, mount_path, read_only = _split_mount(raw_spec, raw=raw_spec)
+        if mount_path is None:
+            raise CLIError(
+                f"Missing mount path in volume spec '{raw_spec}'. Expected 'LOCAL_DIR:/MOUNT_PATH[:ro|:rw]' (e.g. './data:/data')."
+            )
+        if not Path(source).expanduser().is_dir():
+            raise CLIError(
+                f"Volume source '{source}' is not an existing local directory. "
+                "To mount a repo or bucket instead, use the 'hf://' syntax (e.g. 'hf://buckets/my-org/my-bucket:/data')."
+            )
+        volume = api.sync_job_volume(
+            source,
+            mount_path,
+            read_only=read_only if read_only is not None else True,
+            namespace=namespace,
+        )
+        if volume.read_only is False:
+            out.hint(
+                f"Volume '{mount_path}' is mounted read-write. Once the job is over, pull back its data with:\n"
+                f"  hf buckets sync hf://buckets/{volume.source}/{volume.path} {source}"
+            )
+        result.append(volume)
+    return result
+
+
+STATS_UPDATE_MIN_INTERVAL = 0.1  # we set a limit here since there is one update per second per job
+
+# Common job-related options
+ImageArg = Annotated[
+    str,
+    Argument(
+        help="The Docker image to use.",
+    ),
+]
+
+ImageOpt = Annotated[
+    str | None,
+    Option(
+        help="Use a custom Docker image with `uv` installed.",
+    ),
+]
+
+FlavorOpt = Annotated[
+    str | None,
+    Option(
+        help="Flavor for the hardware. Run 'hf jobs hardware' to list available flavors. Defaults to `cpu-basic`.",
+        click_type=SoftChoice(JobHardware),
+    ),
+]
+
+LabelsOpt = Annotated[
+    list[str] | None,
+    Option(
+        "-l",
+        "--label",
+        help="Set labels. E.g. --label KEY=VALUE or --label LABEL",
+    ),
+]
+
+TimeoutOpt = Annotated[
+    str | None,
+    Option(
+        help="Max duration: int with s (seconds, default), m (minutes), h (hours) or d (days).",
+    ),
+]
+
+DetachOpt = Annotated[
+    bool,
+    Option(
+        "-d",
+        "--detach",
+        help="Run the Job in the background and print the Job ID.",
+    ),
+]
+
+NamespaceOpt = Annotated[
+    str | None,
+    Option(
+        help="The namespace where the job will be running. Defaults to the current user's namespace.",
+    ),
+]
+
+ExposeOpt = Annotated[
+    list[int] | None,
+    Option(
+        "--expose",
+        help="Expose a container port through the jobs proxy. Repeat the flag for multiple ports (e.g. `--expose 8000 --expose 8001`). Each exposed port is reachable on the public jobs domain; access requires an HF token with read access to the job's namespace.",
+    ),
+]
+
+SshEnabledOpt = Annotated[
+    bool,
+    Option(
+        "--ssh",
+        help="Make the job's container reachable over SSH. Connect with `hf jobs ssh <job_id>`. Requires an SSH public key registered on https://huggingface.co/settings/keys.",
+    ),
+]
+
+WithOpt = Annotated[
+    list[str] | None,
+    Option(
+        "--with",
+        help="Run with the given packages installed",
+    ),
+]
+
+PythonOpt = Annotated[
+    str | None,
+    Option(
+        "-p",
+        "--python",
+        help="The Python interpreter to use for the run environment",
+    ),
+]
+
+SuspendOpt = Annotated[
+    bool | None,
+    Option(
+        help="Suspend (pause) the scheduled Job",
+    ),
+]
+
+ConcurrencyOpt = Annotated[
+    bool | None,
+    Option(
+        help="Allow multiple instances of this Job to run concurrently",
+    ),
+]
+
+ScheduleArg = Annotated[
+    str,
+    Argument(
+        help="One of annually, yearly, monthly, weekly, daily, hourly, or a CRON schedule expression.",
+    ),
+]
+
+ScriptArg = Annotated[
+    str,
+    Argument(
+        help="UV script to run (local file or URL)",
+    ),
+]
+
+ScriptArgsArg = Annotated[
+    list[str] | None,
+    Argument(
+        help="Arguments for the script",
+    ),
+]
+
+
+CommandArg = Annotated[
+    list[str],
+    Argument(
+        help="The command to run.",
+    ),
+]
+
+JobIdArg = Annotated[
+    str,
+    Argument(
+        help="Job ID (or 'namespace/job_id')",
+    ),
+]
+
+JobIdsArg = Annotated[
+    list[str] | None,
+    Argument(
+        help="Job IDs (or 'namespace/job_id')",
+    ),
+]
+
+ScheduledJobIdArg = Annotated[
+    str,
+    Argument(
+        help="Scheduled Job ID (or 'namespace/scheduled_job_id')",
+    ),
+]
+
+JobVolumesOpt = Annotated[
+    list[str] | None,
+    Option(
+        "-v",
+        "--volume",
+        help="Mount one or more volumes. Format: hf://[TYPE/]SOURCE:/MOUNT_PATH[:ro|:rw] or LOCAL_DIR:/MOUNT_PATH[:ro|:rw]. "
+        "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. "
+        "A local directory source is first synced to a bucket and mounted read-only by default. "
+        "E.g. -v hf://datasets/org/ds:/data or -v hf://buckets/org/b:/mnt:ro or -v ./inputs:/inputs",
+    ),
+]
+
+
+jobs_cli = typer_factory(help="Run and manage Jobs on the Hub.")
+
+
+def _stream_logs_and_check_status(api: HfApi, job: JobInfo) -> None:
+    """Stream Job logs until the Job ends, then fail the command if the Job did not complete successfully."""
+    for log in api.fetch_job_logs(job_id=job.id, namespace=job.owner.name, follow=True):
+        out.text(log)
+    # The log stream can end while the Job is still scheduling or shutting down: settle the final state.
+    final = api.wait_for_job(job_id=job.id, namespace=job.owner.name)
+    if final.status.stage != JobStage.COMPLETED:
+        message = f": {final.status.message}" if final.status.message else ""
+        raise CLIError(f"Job {final.id} finished with stage '{final.status.stage}'{message}")
+    out.text(f"Job {final.id} completed")
+
+
+@jobs_cli.command(
+    "run",
+    context_settings={"ignore_unknown_options": True},
+    examples=[
+        "hf jobs run python:3.12 python -c 'print(\"Hello!\")'",
+        "hf jobs run --detach python:3.12 python script.py",
+        "hf jobs run -e FOO=foo python:3.12 python script.py",
+        "hf jobs run --secrets HF_TOKEN python:3.12 python script.py",
+        "hf jobs run -v hf://org/my-model:/data -v hf://buckets/org/b:/mnt python:3.12 python script.py",
+    ],
+)
+def jobs_run(
+    image: ImageArg,
+    command: CommandArg,
+    env: EnvOpt = None,
+    secrets: SecretsOpt = None,
+    label: LabelsOpt = None,
+    volume: JobVolumesOpt = None,
+    env_file: EnvFileOpt = None,
+    secrets_file: SecretsFileOpt = None,
+    flavor: FlavorOpt = None,
+    timeout: TimeoutOpt = None,
+    detach: DetachOpt = False,
+    expose: ExposeOpt = None,
+    ssh: SshEnabledOpt = False,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Run a Job."""
+    env_map = parse_env_map(env, env_file)
+    secrets_map = parse_env_map(secrets, secrets_file)
+
+    api = get_hf_api(token=token)
+    job = api.run_job(
+        image=image,
+        command=command,
+        env=env_map,
+        secrets=secrets_map,
+        labels=_parse_labels_map(label),
+        volumes=_parse_and_sync_job_volumes(volume, api=api, namespace=namespace),
+        flavor=flavor,
+        timeout=timeout,
+        expose=expose,
+        ssh=ssh,
+        namespace=namespace,
+    )
+    out.result("Job started", id=job.id, url=job.url)
+    if isinstance(job.status.expose_urls, list):
+        urls = "\n".join(f"  {url}" for url in job.status.expose_urls)
+        out.hint(f"Exposed ports are reachable at (requires an HF token with read access to the job):\n{urls}")
+    if isinstance(job.status.ssh_url, str):
+        out.hint(f"Use `hf jobs ssh {job.owner.name}/{job.id}` to open an SSH session into the job.")
+    if detach:
+        job_ref = f"{job.owner.name}/{job.id}"
+        out.hint(f"Use `hf jobs logs -f {job_ref}` to stream logs, or `hf jobs inspect {job_ref}` to check status.")
+        out.hint(f"Use `hf jobs wait {job_ref}` to block until it finishes.")
+        return
+    _stream_logs_and_check_status(api, job)
+
+
+@jobs_cli.command(
+    "logs",
+    examples=[
+        "hf jobs logs <job_id>",
+        "hf jobs logs -f <job_id>",
+        "hf jobs logs --tail 20 <job_id>",
+        "hf jobs logs -f --tail 100 <job_id>",
+    ],
+)
+def jobs_logs(
+    job_id: JobIdArg,
+    follow: Annotated[
+        bool,
+        Option(
+            "-f",
+            "--follow",
+            help="Follow log output (stream until the job completes). Without this flag, only currently available logs are printed.",
+        ),
+    ] = False,
+    tail: Annotated[
+        int | None,
+        Option(
+            "-n",
+            "--tail",
+            help="Number of lines to show from the end of the logs. When combined with --follow, starts streaming from the last N lines.",
+        ),
+    ] = None,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Fetch the logs of a Job.
+
+    By default, prints currently available logs and exits (non-blocking).
+    Use --follow/-f to stream logs in real-time until the job completes.
+    Use --tail/-n to limit the number of lines returned (server-side when supported).
+
+    Note: following exits when the log stream ends, regardless of whether the Job
+    succeeded or failed. Run `hf jobs inspect <job_id>` to check the final status.
+    """
+    job_id, namespace = _parse_namespace_from_job_id(job_id, namespace)
+
+    api = get_hf_api(token=token)
+    logs = api.fetch_job_logs(job_id=job_id, namespace=namespace, follow=follow, tail=tail)
+    for log in logs:
+        out.text(log)
+    if follow:
+        job_ref = f"{namespace}/{job_id}" if namespace else job_id
+        out.hint(f"Stream ended. Run `hf jobs inspect {job_ref}` to check the final status (e.g. COMPLETED or ERROR).")
+
+
+def _matches_filters(job_properties: dict[str, str], filters: list[tuple[str, str, str]]) -> bool:
+    """Check if scheduled job matches all specified filters."""
+    for key, op_str, pattern in filters:
+        value = job_properties.get(key)
+        if value is None:
+            if op_str == "!=":
+                continue
+            return False
+        match = fnmatch(value.lower(), pattern.lower())
+        if (op_str == "=" and not match) or (op_str == "!=" and match):
+            return False
+    return True
+
+
+def _clear_line(n: int) -> None:
+    LINE_UP = "\033[1A"
+    LINE_CLEAR = "\x1b[2K"
+    for i in range(n):
+        print(LINE_UP, end=LINE_CLEAR)
+
+
+def _get_jobs_stats_rows(
+    job_id: str, metrics_stream: Iterable[dict[str, Any]], table_headers: list[str]
+) -> Iterable[tuple[bool, str, list[list[str | int]]]]:
+    for metrics in metrics_stream:
+        row = [
+            job_id,
+            f"{metrics['cpu_usage_pct']}%",
+            round(metrics["cpu_millicores"] / 1000.0, 1),
+            f"{round(100 * metrics['memory_used_bytes'] / metrics['memory_total_bytes'], 2)}%",
+            f"{_format_size(metrics['memory_used_bytes'])}B / {_format_size(metrics['memory_total_bytes'])}B",
+            f"{_format_size(metrics['rx_bps'])}bps / {_format_size(metrics['tx_bps'])}bps",
+        ]
+        if metrics["gpus"] and isinstance(metrics["gpus"], dict):
+            rows = [row] + [[""] * len(row)] * (len(metrics["gpus"]) - 1)
+            for row, gpu_id in zip(rows, sorted(metrics["gpus"])):
+                gpu = metrics["gpus"][gpu_id]
+                row += [
+                    f"{gpu['utilization']}%",
+                    f"{round(100 * gpu['memory_used_bytes'] / gpu['memory_total_bytes'], 2)}%",
+                    f"{_format_size(gpu['memory_used_bytes'])}B / {_format_size(gpu['memory_total_bytes'])}B",
+                ]
+        else:
+            row += ["N/A"] * (len(table_headers) - len(row))
+            rows = [row]
+        yield False, job_id, rows
+    yield True, job_id, []
+
+
+@jobs_cli.command("stats", examples=["hf jobs stats <job_id>"])
+def jobs_stats(
+    job_ids: JobIdsArg = None,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Fetch the resource usage statistics and metrics of Jobs"""
+    if job_ids is not None:
+        parsed_ids = []
+        for job_id in job_ids:
+            job_id, namespace = _parse_namespace_from_job_id(job_id, namespace)
+            parsed_ids.append(job_id)
+        job_ids = parsed_ids
+    api = get_hf_api(token=token)
+    if namespace is None:
+        namespace = api.whoami()["name"]
+    if job_ids is None:
+        job_ids = [
+            job.id
+            for job in api.list_jobs(namespace=namespace)
+            if (job.status.stage if job.status else "UNKNOWN") in ("RUNNING", "UPDATING")
+        ]
+    if len(job_ids) == 0:
+        out.text("No running jobs found")
+        return
+    table_headers = [
+        "JOB ID",
+        "CPU %",
+        "NUM CPU",
+        "MEM %",
+        "MEM USAGE",
+        "NET I/O",
+        "GPU UTIL %",
+        "GPU MEM %",
+        "GPU MEM USAGE",
+    ]
+    with multiprocessing.pool.ThreadPool(len(job_ids)) as pool:
+        rows_per_job_id: dict[str, list[list[str | int]]] = {}
+        for job_id in job_ids:
+            row: list[str | int] = [job_id]
+            row += ["-- / --" if ("/" in header or "USAGE" in header) else "--" for header in table_headers[1:]]
+            rows_per_job_id[job_id] = [row]
+        last_update_time = time.time()
+        total_rows = [row for job_id in rows_per_job_id for row in rows_per_job_id[job_id]]
+        # In-place refresh (cursor-up + clear) requires a fixed line count and layout —
+        # `out.table`'s mode-dependent formatting would break it.
+        print(_tabulate(total_rows, headers=table_headers))
+
+        kwargs_list = [
+            {
+                "job_id": job_id,
+                "metrics_stream": api.fetch_job_metrics(job_id=job_id, namespace=namespace),
+                "table_headers": table_headers,
+            }
+            for job_id in job_ids
+        ]
+        for done, job_id, rows in iflatmap_unordered(pool, _get_jobs_stats_rows, kwargs_list=kwargs_list):
+            if done:
+                rows_per_job_id.pop(job_id, None)
+            else:
+                rows_per_job_id[job_id] = rows
+            now = time.time()
+            if now - last_update_time >= STATS_UPDATE_MIN_INTERVAL:
+                _clear_line(2 + len(total_rows))
+                total_rows = [row for job_id in rows_per_job_id for row in rows_per_job_id[job_id]]
+                print(_tabulate(total_rows, headers=table_headers))
+                last_update_time = now
+
+
+@jobs_cli.command(
+    "list | ls | ps",
+    examples=[
+        "hf jobs ls",
+        "hf jobs ls -a",
+        "hf jobs ls --status running,scheduling",
+        "hf jobs ls --label env=prod --label team=ml",
+        "hf jobs ls --all --label hf-sandbox=1",
+    ],
+)
+def jobs_ps(
+    all: Annotated[
+        bool,
+        Option(
+            "-a",
+            "--all",
+            help="Show all Jobs (default shows running and scheduling). Cannot be combined with --status.",
+        ),
+    ] = False,
+    status: Annotated[
+        list[str] | None,
+        Option(
+            "--status",
+            click_type=SoftChoice(JobStage),
+            help="Only show Jobs with the given status. Comma-separated or repeated, e.g. `--status running,scheduling`.",
+        ),
+    ] = None,
+    label: Annotated[
+        list[str] | None,
+        Option(
+            "-l",
+            "--label",
+            help="Only show Jobs with the given `key=value` label. Repeat to require several labels, e.g. `--label env=prod --label team=ml`.",
+        ),
+    ] = None,
+    limit: Annotated[
+        int,
+        Option(
+            "--limit",
+            help="Maximum number of Jobs to display. Set to 0 to show all (no limit).",
+        ),
+    ] = 100,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+    filter: Annotated[
+        list[str] | None,
+        Option(
+            "-f",
+            "--filter",
+            help="(Deprecated) Use `--status` and `--label` instead.",
+        ),
+    ] = None,
+) -> None:
+    """List Jobs.
+
+    Use `--status` to filter by status (see [`JobStage`] for possible values) and `--label` to filter by `key=value`
+    labels. A Job must match every filter to be listed.
+    """
+    api = get_hf_api(token=token)
+
+    if filter:
+        out.warning(
+            f"Ignoring filter '{filter}'."
+            " `-f`/`--filter` is deprecated and will be removed in a future release. Use `--status`/`--label`."
+        )
+
+    if all and status:
+        raise CLIError("`-a`/`--all` cannot be combined with `--status`.")
+
+    # Status filtering (default to active Jobs, unless `--all` or `--status` is provided).
+    raw_statuses: list[str] = []
+    for value in status or []:
+        raw_statuses.extend(part.strip() for part in value.split(",") if part.strip())
+
+    server_statuses: list[str] | None
+    if raw_statuses:
+        server_statuses = raw_statuses
+    elif all:
+        server_statuses = None
+    else:
+        server_statuses = [JobStage.RUNNING.value, JobStage.SCHEDULING.value]
+
+    # Labels filtering
+    labels: dict[str, str] = {}
+    for item in label or []:
+        if "=" not in item:
+            raise CLIError(f"Invalid label filter '{item}': must be in the form 'key=value'")
+        key, value = item.split("=")
+        labels[key] = value
+
+    jobs_iter = api.list_jobs(namespace=namespace, status=server_statuses, labels=labels or None)
+
+    # Apply the display limit. Fetch one extra Job to detect (and warn about) truncation.
+    truncated = False
+    if limit > 0:
+        jobs = list(itertools.islice(jobs_iter, limit + 1))
+        if len(jobs) > limit:
+            truncated = True
+            jobs = jobs[:limit]
+    else:
+        jobs = list(jobs_iter)
+
+    # Build display items. Augment the raw api dict with curated, table-friendly columns.
+    job_items: list[dict[str, Any]] = []
+    for job in jobs:
+        job_item = _dataclass_to_dict(job)
+        durations = job_item.get("durations") or {}
+        cmd = job_item.get("command") or []
+        job_item["job_id"] = job_item.get("id", "")
+        job_item["image/space"] = job_item.get("docker_image") or "N/A"
+        job_item["command"] = " ".join(cmd) if cmd else "N/A"
+        job_item["created"] = job_item["created_at"][:19].replace("T", " ") if job_item.get("created_at") else "N/A"
+        job_item["status"] = (job_item.get("status") or {}).get("stage", "UNKNOWN")
+        job_item["runtime"] = format_duration(durations.get("running_secs"))
+        job_items.append(job_item)
+
+    out.table(
+        job_items,
+        headers=["job_id", "image/space", "command", "created", "status", "runtime"],
+        id_key="job_id",
+    )
+    if truncated:
+        out.hint(f"Output truncated to {limit} Jobs. Use `--limit 0` to show all (or `--limit N`).")
+    if not job_items:
+        if raw_statuses or labels:
+            filters_msg = ", ".join(
+                [*(f"status={s}" for s in raw_statuses), *(f"label={k}={v}" for k, v in labels.items())]
+            )
+            out.text(f"No jobs matched filters: {filters_msg}")
+        elif not all:
+            out.hint("No running jobs. Use `-a`/`--all` to include finished (and failed) jobs.")
+
+
+@jobs_cli.command("hardware", examples=["hf jobs hardware"])
+def jobs_hardware() -> None:
+    """List available hardware options for Jobs"""
+    api = get_hf_api()
+    hardware_list = api.list_jobs_hardware()
+    items = []
+    for hw in hardware_list:
+        accelerator_info = ""
+        if hw.accelerator:
+            accelerator_info = f"{hw.accelerator.quantity}x {hw.accelerator.model} ({hw.accelerator.vram})"
+        cost_min = f"${hw.unit_cost_usd:.4f}" if hw.unit_cost_usd else "free"
+        cost_hour = f"${hw.unit_cost_usd * 60:.2f}" if hw.unit_cost_usd else "free"
+        items.append(
+            {
+                "name": hw.name,
+                "pretty name": hw.pretty_name,
+                "cpu": hw.cpu,
+                "ram": hw.ram,
+                "storage": hw.ephemeral_storage,
+                "accelerator": accelerator_info,
+                "cost/min": cost_min,
+                "cost/hour": cost_hour,
+            }
+        )
+    out.table(items)
+    out.hint("Use `hf jobs run --flavor <name> ...` to request a specific hardware flavor.")
+
+
+@jobs_cli.command("inspect", examples=["hf jobs inspect <job_id>"])
+def jobs_inspect(
+    job_ids: Annotated[
+        list[str],
+        Argument(
+            help="Job IDs to inspect (or 'namespace/job_id')",
+        ),
+    ],
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Display detailed information on one or more Jobs"""
+    parsed_ids = []
+    for job_id in job_ids:
+        job_id, namespace = _parse_namespace_from_job_id(job_id, namespace)
+        parsed_ids.append(job_id)
+    job_ids = parsed_ids
+    api = get_hf_api(token=token)
+    jobs = [api.inspect_job(job_id=job_id, namespace=namespace) for job_id in job_ids]
+    out.table([_dataclass_to_dict(job) for job in jobs])
+
+
+@jobs_cli.command("cancel", examples=["hf jobs cancel <job_id>"])
+def jobs_cancel(
+    job_id: JobIdArg,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Cancel a Job"""
+    job_id, namespace = _parse_namespace_from_job_id(job_id, namespace)
+    api = get_hf_api(token=token)
+    api.cancel_job(job_id=job_id, namespace=namespace)
+    out.result("Job cancelled", id=job_id)
+
+
+@jobs_cli.command(
+    "wait",
+    examples=[
+        "hf jobs wait <job_id>",
+        "hf jobs wait <job_id_1> <job_id_2>",
+        "hf jobs ls -q | xargs hf jobs wait",
+    ],
+)
+def jobs_wait(
+    job_ids: Annotated[
+        list[str],
+        Argument(
+            help="Job IDs to wait for (or 'namespace/job_id').",
+        ),
+    ],
+    timeout: Annotated[
+        str | None,
+        Option(
+            help="Max time to wait: int with s (seconds, default), m (minutes), h (hours) or d (days).",
+        ),
+    ] = None,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Wait for one or more Jobs to reach a terminal state.
+
+    Blocks until every Job has finished, then exits with code 0 if all Jobs completed
+    successfully, or a non-zero exit code if any Job was canceled, errored or deleted.
+
+    All Jobs must belong to the same namespace.
+    """
+    parsed_ids = []
+    namespaces = set()
+    for job_id in job_ids:
+        parsed_id, parsed_namespace = _parse_namespace_from_job_id(job_id, namespace)
+        parsed_ids.append(parsed_id)
+        namespaces.add(parsed_namespace)
+    if len(namespaces) > 1:
+        raise CLIError(
+            "All Job IDs must be in the same namespace, got: "
+            + ", ".join(str(ns) for ns in sorted(namespaces, key=str))
+        )
+    namespace = namespaces.pop()
+    timeout_secs = parse_duration(timeout) if timeout is not None else None
+
+    api = get_hf_api(token=token)
+    status = out.status(f"Waiting for {len(parsed_ids)} Job(s) to finish...")
+    try:
+        jobs = api.wait_for_job(parsed_ids, timeout=timeout_secs, namespace=namespace)
+    except TimeoutError:
+        status.done("Timed out.")
+        raise CLIError(f"Timed out after {timeout} waiting for Job(s) to finish.") from None
+    status.done(f"{len(jobs)} Job(s) finished.")
+
+    out.table([{"id": job.id, "stage": str(job.status.stage), "message": job.status.message} for job in jobs])
+    failed = [job for job in jobs if job.status.stage != JobStage.COMPLETED]
+    if failed:
+        raise CLIError(
+            f"{len(failed)} of {len(jobs)} Job(s) did not complete successfully: "
+            + ", ".join(f"{job.id} ({job.status.stage})" for job in failed)
+        )
+
+
+@jobs_cli.command(
+    "labels",
+    examples=[
+        "hf jobs labels <job_id> --label env=prod --label team=ml",
+        "hf jobs labels <job_id> --clear",
+    ],
+)
+def jobs_labels(
+    job_id: JobIdArg,
+    label: LabelsOpt = None,
+    clear: Annotated[bool, Option("--clear", help="Remove all labels from the job.")] = False,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Update labels on a Job. Replaces all existing labels."""
+    if not label and not clear:
+        raise CLIError("Please set at least one label with --label. To remove all labels, pass --clear.")
+    if label and clear:
+        raise CLIError(
+            "Cannot set labels and clear them at the same time. Please use either --label or --clear, not both."
+        )
+    job_id, namespace = _parse_namespace_from_job_id(job_id, namespace)
+    labels = _parse_labels_map(label) or {}
+    api = get_hf_api(token=token)
+    job = api.update_job_labels(job_id=job_id, labels=labels, namespace=namespace)
+    out.result("Labels updated", id=job.id)
+
+
+@jobs_cli.command(
+    "ssh",
+    examples=[
+        "hf jobs ssh <job_id>",
+        "hf jobs ssh <job_id> --dry-run",
+        "hf jobs ssh <job_id> -i ~/.ssh/id_ed25519",
+    ],
+)
+def jobs_ssh(
+    job_id: JobIdArg,
+    identity_file: SshIdentityFileOpt = None,
+    dry_run: SshDryRunOpt = False,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """SSH into a running Job.
+
+    If the Job is not yet running, waits until it reaches the RUNNING state before
+    connecting. Requires the Job to be started with SSH enabled (`hf jobs run --ssh ...`)
+    and your SSH public key to be registered at https://huggingface.co/settings/keys.
+    """
+    job_id, namespace = _parse_namespace_from_job_id(job_id, namespace)
+    api = get_hf_api(token=token)
+    job = api.inspect_job(job_id=job_id, namespace=namespace)
+    if job.status.ssh_url is None:
+        raise CLIError("SSH is not enabled on this job. Start a job with SSH support using `hf jobs run --ssh ...`.")
+    if job.status.stage in TERMINAL_JOB_STAGES:
+        raise CLIError(f"Cannot SSH into job '{job.id}': job has already finished (stage: '{job.status.stage}').")
+    if job.status.stage != JobStage.RUNNING:
+        status = out.status(f"Waiting for job '{job.id}' to be running (stage: '{job.status.stage}')...")
+        job = api.wait_for_job(job_id=job.id, namespace=namespace, stages=[JobStage.RUNNING])
+        if job.status.stage != JobStage.RUNNING:
+            status.done("Job finished.")
+            raise CLIError(
+                f"Cannot SSH into job '{job.id}': job finished before reaching RUNNING (stage: '{job.status.stage}')."
+            )
+        status.done("Job is running.")
+    ssh_url = urlsplit(job.status.ssh_url)
+    exec_ssh(
+        f"{ssh_url.username}@{ssh_url.hostname}",  # type: ignore
+        port=ssh_url.port,
+        identity_file=identity_file,
+        dry_run=dry_run,
+    )
+
+
+uv_app = typer_factory(help="Run UV scripts (Python with inline dependencies) on HF infrastructure.")
+jobs_cli.add_group(uv_app, name="uv")
+
+
+@uv_app.command(
+    "run",
+    context_settings={"ignore_unknown_options": True},
+    examples=[
+        "hf jobs uv run my_script.py",
+        "hf jobs uv run --detach my_script.py",
+        "hf jobs uv run ml_training.py --flavor a10g-small",
+        "hf jobs uv run --with transformers train.py",
+        "hf jobs uv run -v hf://org/my-model:/data -v hf://buckets/org/b:/mnt script.py",
+    ],
+)
+def jobs_uv_run(
+    script: ScriptArg,
+    script_args: ScriptArgsArg = None,
+    image: ImageOpt = None,
+    flavor: FlavorOpt = None,
+    env: EnvOpt = None,
+    secrets: SecretsOpt = None,
+    label: LabelsOpt = None,
+    volume: JobVolumesOpt = None,
+    env_file: EnvFileOpt = None,
+    secrets_file: SecretsFileOpt = None,
+    timeout: TimeoutOpt = None,
+    detach: DetachOpt = False,
+    expose: ExposeOpt = None,
+    ssh: SshEnabledOpt = False,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+    with_: WithOpt = None,
+    python: PythonOpt = None,
+) -> None:
+    """Run a UV script (local file or URL) on HF infrastructure"""
+    env_map = parse_env_map(env, env_file)
+    secrets_map = parse_env_map(secrets, secrets_file)
+
+    api = get_hf_api(token=token)
+    job = api.run_uv_job(
+        script=script,
+        script_args=script_args or [],
+        dependencies=with_,
+        python=python,
+        image=image,
+        env=env_map,
+        secrets=secrets_map,
+        labels=_parse_labels_map(label),
+        volumes=_parse_and_sync_job_volumes(volume, api=api, namespace=namespace),
+        flavor=flavor,
+        timeout=timeout,
+        expose=expose,
+        ssh=ssh,
+        namespace=namespace,
+    )
+    out.result("Job started", id=job.id, url=job.url)
+    if isinstance(job.status.expose_urls, list):
+        urls = "\n".join(f"  {url}" for url in job.status.expose_urls)
+        out.hint(f"Exposed ports are reachable at (requires an HF token with read access to the job):\n{urls}")
+    if isinstance(job.status.ssh_url, str):
+        out.hint(f"Use `hf jobs ssh {job.owner.name}/{job.id}` to open an SSH session into the job.")
+    if detach:
+        job_ref = f"{job.owner.name}/{job.id}"
+        out.hint(f"Use `hf jobs logs -f {job_ref}` to stream logs, or `hf jobs inspect {job_ref}` to check status.")
+        out.hint(f"Use `hf jobs wait {job_ref}` to block until it finishes.")
+        return
+    _stream_logs_and_check_status(api, job)
+
+
+scheduled_app = typer_factory(help="Create and manage scheduled Jobs on the Hub.")
+jobs_cli.add_group(scheduled_app, name="scheduled")
+
+
+@scheduled_app.command(
+    "run",
+    context_settings={"ignore_unknown_options": True},
+    examples=['hf jobs scheduled run "0 0 * * *" python:3.12 python script.py'],
+)
+def scheduled_run(
+    schedule: ScheduleArg,
+    image: ImageArg,
+    command: CommandArg,
+    suspend: SuspendOpt = None,
+    concurrency: ConcurrencyOpt = None,
+    env: EnvOpt = None,
+    secrets: SecretsOpt = None,
+    label: LabelsOpt = None,
+    volume: JobVolumesOpt = None,
+    env_file: EnvFileOpt = None,
+    secrets_file: SecretsFileOpt = None,
+    flavor: FlavorOpt = None,
+    timeout: TimeoutOpt = None,
+    expose: ExposeOpt = None,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Schedule a Job."""
+    env_map = parse_env_map(env, env_file)
+    secrets_map = parse_env_map(secrets, secrets_file)
+
+    api = get_hf_api(token=token)
+    scheduled_job = api.create_scheduled_job(
+        image=image,
+        command=command,
+        schedule=schedule,
+        suspend=suspend,
+        concurrency=concurrency,
+        env=env_map,
+        secrets=secrets_map,
+        labels=_parse_labels_map(label),
+        volumes=_parse_and_sync_job_volumes(volume, api=api, namespace=namespace),
+        flavor=flavor,
+        timeout=timeout,
+        expose=expose,
+        namespace=namespace,
+    )
+    out.result("Scheduled Job created", id=scheduled_job.id)
+    out.hint(f"Use `hf jobs scheduled inspect {scheduled_job.id}` to view its details.")
+
+
+@scheduled_app.command("list | ls | ps", examples=["hf jobs scheduled ls"])
+def scheduled_ps(
+    all: Annotated[
+        bool,
+        Option(
+            "-a",
+            "--all",
+            help="Show all scheduled Jobs (default hides suspended)",
+        ),
+    ] = False,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+    filter: Annotated[
+        list[str] | None,
+        Option(
+            "-f",
+            "--filter",
+            help="Filter output based on conditions provided (format: key=value)",
+        ),
+    ] = None,
+) -> None:
+    """List scheduled Jobs"""
+    api = get_hf_api(token=token)
+    scheduled_jobs = api.list_scheduled_jobs(namespace=namespace)
+    filters: list[tuple[str, str, str]] = []
+    for f in filter or []:
+        if "=" in f:
+            key, value = f.split("=", 1)
+            # Negate predicate in case of key!=value
+            if key.endswith("!"):
+                op = "!="
+                key = key[:-1]
+            else:
+                op = "="
+            filters.append((key.lower(), op, value.lower()))
+        else:
+            out.warning(f"Ignoring invalid filter format '{f}'. Use key=value format.")
+
+    # Filter scheduled jobs (operating on ScheduledJobInfo objects to preserve existing filter behavior)
+    filtered_jobs = []
+    for scheduled_job in scheduled_jobs:
+        suspend = scheduled_job.suspend or False
+        if not all and suspend:
+            continue
+        image_or_space = scheduled_job.job_spec.docker_image or "N/A"
+        cmd = scheduled_job.job_spec.command or []
+        command_str = " ".join(cmd) if cmd else "N/A"
+        props = {"id": scheduled_job.id, "image": image_or_space, "suspend": str(suspend), "command": command_str}
+        if not _matches_filters(props, filters):
+            continue
+        filtered_jobs.append(scheduled_job)
+
+    # Build display items. Augment with curated columns.
+    items: list[dict[str, Any]] = []
+    for sj in filtered_jobs:
+        item = _dataclass_to_dict(sj)
+        job_spec = item.get("job_spec") or {}
+        status_dict = item.get("status") or {}
+        last_job = status_dict.get("last_job")
+        cmd = job_spec.get("command") or []
+        item["image/space"] = job_spec.get("docker_image") or "N/A"
+        item["command"] = " ".join(cmd) if cmd else "N/A"
+        item["last_run"] = last_job["at"][:19].replace("T", " ") if last_job and last_job.get("at") else "N/A"
+        item["next_run"] = (
+            status_dict["next_job_run_at"][:19].replace("T", " ") if status_dict.get("next_job_run_at") else "N/A"
+        )
+        item["suspend"] = item.get("suspend") or False
+        items.append(item)
+
+    out.table(
+        items,
+        headers=["id", "schedule", "image/space", "command", "last_run", "next_run", "suspend"],
+        id_key="id",
+    )
+    if not items and filters:
+        filters_msg = ", ".join(f"{k}{o}{v}" for k, o, v in filters)
+        out.text(f"No scheduled jobs matched filters: {filters_msg}")
+    if items:
+        first_item_id = items[0]["id"]
+        out.hint(f"Use `hf jobs scheduled inspect {first_item_id}` to view details about a scheduled job.")
+        out.hint(f"Use `hf jobs scheduled trigger {first_item_id}` to trigger a scheduled job immediately.")
+
+
+@scheduled_app.command("inspect", examples=["hf jobs scheduled inspect <id>"])
+def scheduled_inspect(
+    scheduled_job_ids: Annotated[
+        list[str],
+        Argument(
+            help="Scheduled Job IDs to inspect (or 'namespace/scheduled_job_id')",
+        ),
+    ],
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Display detailed information on one or more scheduled Jobs"""
+    parsed_ids = []
+    for job_id in scheduled_job_ids:
+        job_id, namespace = _parse_namespace_from_job_id(job_id, namespace)
+        parsed_ids.append(job_id)
+    scheduled_job_ids = parsed_ids
+    api = get_hf_api(token=token)
+    scheduled_jobs = [
+        api.inspect_scheduled_job(scheduled_job_id=scheduled_job_id, namespace=namespace)
+        for scheduled_job_id in scheduled_job_ids
+    ]
+    out.table([_dataclass_to_dict(scheduled_job) for scheduled_job in scheduled_jobs])
+
+
+@scheduled_app.command("delete", examples=["hf jobs scheduled delete <id>"])
+def scheduled_delete(
+    scheduled_job_id: ScheduledJobIdArg,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Delete a scheduled Job."""
+    scheduled_job_id, namespace = _parse_namespace_from_job_id(scheduled_job_id, namespace)
+    api = get_hf_api(token=token)
+    api.delete_scheduled_job(scheduled_job_id=scheduled_job_id, namespace=namespace)
+    out.result("Scheduled Job deleted", id=scheduled_job_id)
+
+
+@scheduled_app.command("suspend", examples=["hf jobs scheduled suspend <id>"])
+def scheduled_suspend(
+    scheduled_job_id: ScheduledJobIdArg,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Suspend (pause) a scheduled Job."""
+    scheduled_job_id, namespace = _parse_namespace_from_job_id(scheduled_job_id, namespace)
+    api = get_hf_api(token=token)
+    api.suspend_scheduled_job(scheduled_job_id=scheduled_job_id, namespace=namespace)
+    out.result("Scheduled Job suspended", id=scheduled_job_id)
+    out.hint(f"Use `hf jobs scheduled resume {scheduled_job_id}` to resume it.")
+
+
+@scheduled_app.command("resume", examples=["hf jobs scheduled resume <id>"])
+def scheduled_resume(
+    scheduled_job_id: ScheduledJobIdArg,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Resume (unpause) a scheduled Job."""
+    scheduled_job_id, namespace = _parse_namespace_from_job_id(scheduled_job_id, namespace)
+    api = get_hf_api(token=token)
+    api.resume_scheduled_job(scheduled_job_id=scheduled_job_id, namespace=namespace)
+    out.result("Scheduled Job resumed", id=scheduled_job_id)
+
+
+@scheduled_app.command("trigger", examples=["hf jobs scheduled trigger <id>"])
+def scheduled_trigger(
+    scheduled_job_id: ScheduledJobIdArg,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Trigger a scheduled Job to run immediately (does not change the schedule)."""
+    scheduled_job_id, namespace = _parse_namespace_from_job_id(scheduled_job_id, namespace)
+    api = get_hf_api(token=token)
+    job = api.trigger_scheduled_job(scheduled_job_id=scheduled_job_id, namespace=namespace)
+    out.result("Scheduled Job triggered", id=job.id, url=job.url)
+    out.hint(f"Use `hf jobs logs -f {job.owner.name}/{job.id}` to stream logs.")
+
+
+@scheduled_app.command(
+    "labels",
+    examples=[
+        "hf jobs scheduled labels <id> --label env=prod --label team=ml",
+        "hf jobs scheduled labels <id> --clear",
+    ],
+)
+def scheduled_labels(
+    scheduled_job_id: ScheduledJobIdArg,
+    label: LabelsOpt = None,
+    clear: Annotated[bool, Option("--clear", help="Remove all labels from the scheduled job.")] = False,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+) -> None:
+    """Update labels on a scheduled Job. Replaces all existing labels."""
+    if not label and not clear:
+        raise CLIError("Please set at least one label with --label. To remove all labels, pass --clear.")
+    if label and clear:
+        raise CLIError(
+            "Cannot set labels and clear them at the same time. Please use either --label or --clear, not both."
+        )
+    scheduled_job_id, namespace = _parse_namespace_from_job_id(scheduled_job_id, namespace)
+    labels = _parse_labels_map(label) or {}
+    api = get_hf_api(token=token)
+    scheduled_job = api.update_scheduled_job_labels(
+        scheduled_job_id=scheduled_job_id, labels=labels, namespace=namespace
+    )
+    out.result("Labels updated", id=scheduled_job.id)
+
+
+scheduled_uv_app = typer_factory(help="Schedule UV scripts on HF infrastructure.")
+scheduled_app.add_group(scheduled_uv_app, name="uv")
+
+
+@scheduled_uv_app.command(
+    "run",
+    context_settings={"ignore_unknown_options": True},
+    examples=[
+        'hf jobs scheduled uv run "0 0 * * *" script.py',
+        'hf jobs scheduled uv run "0 0 * * *" script.py --with pandas',
+    ],
+)
+def scheduled_uv_run(
+    schedule: ScheduleArg,
+    script: ScriptArg,
+    script_args: ScriptArgsArg = None,
+    suspend: SuspendOpt = None,
+    concurrency: ConcurrencyOpt = None,
+    image: ImageOpt = None,
+    flavor: FlavorOpt = None,
+    env: EnvOpt = None,
+    secrets: SecretsOpt = None,
+    label: LabelsOpt = None,
+    volume: JobVolumesOpt = None,
+    env_file: EnvFileOpt = None,
+    secrets_file: SecretsFileOpt = None,
+    timeout: TimeoutOpt = None,
+    expose: ExposeOpt = None,
+    namespace: NamespaceOpt = None,
+    token: TokenOpt = None,
+    with_: WithOpt = None,
+    python: PythonOpt = None,
+) -> None:
+    """Run a UV script (local file or URL) on HF infrastructure"""
+    env_map = parse_env_map(env, env_file)
+    secrets_map = parse_env_map(secrets, secrets_file)
+
+    api = get_hf_api(token=token)
+    job = api.create_scheduled_uv_job(
+        script=script,
+        script_args=script_args or [],
+        schedule=schedule,
+        suspend=suspend,
+        concurrency=concurrency,
+        dependencies=with_,
+        python=python,
+        image=image,
+        env=env_map,
+        secrets=secrets_map,
+        labels=_parse_labels_map(label),
+        volumes=_parse_and_sync_job_volumes(volume, api=api, namespace=namespace),
+        flavor=flavor,
+        timeout=timeout,
+        expose=expose,
+        namespace=namespace,
+    )
+    out.result("Scheduled Job created", id=job.id)
+    out.hint(f"Use `hf jobs scheduled inspect {job.id}` to view its details.")
+
+
+### UTILS
+
+
+def _parse_labels_map(labels: list[str] | None) -> dict[str, str] | None:
+    """Parse label key-value pairs from CLI arguments.
+
+    Args:
+        labels: List of label strings in KEY=VALUE format. If KEY only, then VALUE is set to empty string.
+
+    Returns:
+        Dictionary mapping label keys to values, or None if no labels provided.
+    """
+    if not labels:
+        return None
+    labels_map: dict[str, str] = {}
+    for label_var in labels:
+        key, value = label_var.split("=", 1) if "=" in label_var else (label_var, "")
+        labels_map[key] = value
+    return labels_map
+
+
+def _tabulate(rows: list[list[str | int]], headers: list[str]) -> str:
+    """
+    Inspired by:
+
+    - stackoverflow.com/a/8356620/593036
+    - stackoverflow.com/questions/9535954/printing-lists-as-tabular-data
+    """
+    col_widths = [max(len(str(x)) for x in col) for col in zip(*rows, headers)]
+    terminal_width = max(shutil.get_terminal_size().columns, len(headers) * 12)
+    while len(headers) + sum(col_widths) > terminal_width:
+        col_to_minimize = col_widths.index(max(col_widths))
+        col_widths[col_to_minimize] //= 2
+        if len(headers) + sum(col_widths) <= terminal_width:
+            col_widths[col_to_minimize] = terminal_width - sum(col_widths) - len(headers) + col_widths[col_to_minimize]
+    row_format = ("{{:{}}} " * len(headers)).format(*col_widths)
+    lines = []
+    lines.append(row_format.format(*headers))
+    lines.append(row_format.format(*["-" * w for w in col_widths]))
+    for row in rows:
+        row_format_args = [
+            str(x)[: col_width - 3] + "..." if len(str(x)) > col_width else str(x)
+            for x, col_width in zip(row, col_widths)
+        ]
+        lines.append(row_format.format(*row_format_args))
+    return "\n".join(lines)
+
+
+T = TypeVar("T")
+
+
+def _write_generator_to_queue(queue: Queue[T], func: Callable[..., Iterable[T]], kwargs: dict) -> None:
+    for result in func(**kwargs):
+        queue.put(result)
+
+
+def iflatmap_unordered(
+    pool: multiprocessing.pool.ThreadPool,
+    func: Callable[..., Iterable[T]],
+    *,
+    kwargs_list: list[dict],
+) -> Iterable[T]:
+    """
+    Takes a function that returns an iterable of items, and run it in parallel using threads to return the flattened iterable of items as they arrive.
+
+    This is inspired by those three `map()` variants, and is the mix of all three:
+
+    * `imap()`: like `map()` but returns an iterable instead of a list of results
+    * `imap_unordered()`: like `imap()` but the output is sorted by time of arrival
+    * `flatmap()`: like `map()` but given a function which returns a list, `flatmap()` returns the flattened list that is the concatenation of all the output lists
+    """
+    queue: Queue[T] = Queue()
+    async_results = [pool.apply_async(_write_generator_to_queue, (queue, func, kwargs)) for kwargs in kwargs_list]
+    try:
+        while True:
+            try:
+                yield queue.get(timeout=0.05)
+            except Empty:
+                if all(async_result.ready() for async_result in async_results) and queue.empty():
+                    break
+    except KeyboardInterrupt:
+        pass
+    finally:
+        # we get the result in case there's an error to raise
+        try:
+            [async_result.get(timeout=0.05) for async_result in async_results]
+        except multiprocessing.TimeoutError:
+            pass