huggingface-hub 0.35.1__py3-none-any.whl → 1.0.0rc1__py3-none-any.whl

huggingface_hub/cli/repo.py

@@ -21,229 +21,171 @@ Usage:
     hf repo create my-cool-model --private
 """
 
-import argparse
-from argparse import _SubParsersAction
-from typing import Optional
+from typing import Annotated, Optional
 
-from requests.exceptions import HTTPError
+import typer
 
-from huggingface_hub.commands import BaseHuggingfaceCLICommand
-from huggingface_hub.commands._cli_utils import ANSI
-from huggingface_hub.constants import REPO_TYPES, SPACES_SDK_TYPES
 from huggingface_hub.errors import HfHubHTTPError, RepositoryNotFoundError, RevisionNotFoundError
-from huggingface_hub.hf_api import HfApi
 from huggingface_hub.utils import logging
 
+from ._cli_utils import (
+    ANSI,
+    PrivateOpt,
+    RepoIdArg,
+    RepoType,
+    RepoTypeOpt,
+    RevisionOpt,
+    TokenOpt,
+    get_hf_api,
+    typer_factory,
+)
 
-logger = logging.get_logger(__name__)
 
+logger = logging.get_logger(__name__)
 
-class RepoCommands(BaseHuggingfaceCLICommand):
-    @staticmethod
-    def register_subcommand(parser: _SubParsersAction):
-        repo_parser = parser.add_parser("repo", help="Manage repos on the Hub.")
-        repo_subparsers = repo_parser.add_subparsers(help="huggingface.co repos related commands")
-
-        # Show help if no subcommand is provided
-        repo_parser.set_defaults(func=lambda args: repo_parser.print_help())
-
-        # CREATE
-        repo_create_parser = repo_subparsers.add_parser("create", help="Create a new repo on huggingface.co")
-        repo_create_parser.add_argument(
-            "repo_id",
-            type=str,
-            help="The ID of the repo to create to (e.g. `username/repo-name`). The username is optional and will be set to your username if not provided.",
-        )
-        repo_create_parser.add_argument(
-            "--repo-type",
-            type=str,
-            help='Optional: set to "dataset" or "space" if creating a dataset or space, default is model.',
-        )
-        repo_create_parser.add_argument(
-            "--space_sdk",
-            type=str,
-            help='Optional: Hugging Face Spaces SDK type. Required when --type is set to "space".',
-            choices=SPACES_SDK_TYPES,
-        )
-        repo_create_parser.add_argument(
-            "--private",
-            action="store_true",
-            help="Whether to create a private repository. Defaults to public unless the organization's default is private.",
-        )
-        repo_create_parser.add_argument(
-            "--token",
-            type=str,
-            help="Hugging Face token. Will default to the locally saved token if not provided.",
-        )
-        repo_create_parser.add_argument(
-            "--exist-ok",
-            action="store_true",
+repo_cli = typer_factory(help="Manage repos on the Hub.")
+tag_app = typer_factory(help="Manage tags for a repo on the Hub.")
+repo_cli.add_typer(tag_app, name="tag")
+
+
+@repo_cli.command("create", help="Create a new repo on the Hub.")
+def repo_create(
+    repo_id: RepoIdArg,
+    repo_type: RepoTypeOpt = RepoType.model,
+    space_sdk: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Hugging Face Spaces SDK type. Required when --type is set to 'space'.",
+        ),
+    ] = None,
+    private: PrivateOpt = False,
+    token: TokenOpt = None,
+    exist_ok: Annotated[
+        bool,
+        typer.Option(
             help="Do not raise an error if repo already exists.",
-        )
-        repo_create_parser.add_argument(
-            "--resource-group-id",
-            type=str,
+        ),
+    ] = False,
+    resource_group_id: Annotated[
+        Optional[str],
+        typer.Option(
             help="Resource group in which to create the repo. Resource groups is only available for Enterprise Hub organizations.",
-        )
-        repo_create_parser.set_defaults(func=lambda args: RepoCreateCommand(args))
-
-        # TAG SUBCOMMANDS
-        repo_tag_parser = repo_subparsers.add_parser("tag", help="Manage tags for a repo on the Hub.")
-        tag_subparsers = repo_tag_parser.add_subparsers(help="Tag actions", dest="tag_action", required=True)
-
-        # tag create
-        tag_create_parser = tag_subparsers.add_parser("create", help="Create a tag for a repo.")
-        tag_create_parser.add_argument(
-            "repo_id", type=str, help="The ID of the repo to tag (e.g. `username/repo-name`)."
-        )
-        tag_create_parser.add_argument("tag", type=str, help="The name of the tag to create.")
-        tag_create_parser.add_argument("-m", "--message", type=str, help="The description of the tag to create.")
-        tag_create_parser.add_argument("--revision", type=str, help="The git revision to tag.")
-        tag_create_parser.add_argument(
-            "--token", type=str, help="A User Access Token generated from https://huggingface.co/settings/tokens."
-        )
-        tag_create_parser.add_argument(
-            "--repo-type",
-            choices=["model", "dataset", "space"],
-            default="model",
-            help="Set the type of repository (model, dataset, or space).",
-        )
-        tag_create_parser.set_defaults(func=lambda args: RepoTagCreateCommand(args))
-
-        # tag list
-        tag_list_parser = tag_subparsers.add_parser("list", help="List tags for a repo.")
-        tag_list_parser.add_argument(
-            "repo_id", type=str, help="The ID of the repo to list tags for (e.g. `username/repo-name`)."
-        )
-        tag_list_parser.add_argument(
-            "--token", type=str, help="A User Access Token generated from https://huggingface.co/settings/tokens."
-        )
-        tag_list_parser.add_argument(
-            "--repo-type",
-            choices=["model", "dataset", "space"],
-            default="model",
-            help="Set the type of repository (model, dataset, or space).",
-        )
-        tag_list_parser.set_defaults(func=lambda args: RepoTagListCommand(args))
-
-        # tag delete
-        tag_delete_parser = tag_subparsers.add_parser("delete", help="Delete a tag from a repo.")
-        tag_delete_parser.add_argument(
-            "repo_id", type=str, help="The ID of the repo to delete the tag from (e.g. `username/repo-name`)."
-        )
-        tag_delete_parser.add_argument("tag", type=str, help="The name of the tag to delete.")
-        tag_delete_parser.add_argument("-y", "--yes", action="store_true", help="Answer Yes to prompts automatically.")
-        tag_delete_parser.add_argument(
-            "--token", type=str, help="A User Access Token generated from https://huggingface.co/settings/tokens."
-        )
-        tag_delete_parser.add_argument(
-            "--repo-type",
-            choices=["model", "dataset", "space"],
-            default="model",
-            help="Set the type of repository (model, dataset, or space).",
-        )
-        tag_delete_parser.set_defaults(func=lambda args: RepoTagDeleteCommand(args))
-
-
-class RepoCreateCommand:
-    def __init__(self, args: argparse.Namespace):
-        self.repo_id: str = args.repo_id
-        self.repo_type: Optional[str] = args.repo_type
-        self.space_sdk: Optional[str] = args.space_sdk
-        self.private: bool = args.private
-        self.token: Optional[str] = args.token
-        self.exist_ok: bool = args.exist_ok
-        self.resource_group_id: Optional[str] = args.resource_group_id
-        self._api = HfApi()
-
-    def run(self):
-        repo_url = self._api.create_repo(
-            repo_id=self.repo_id,
-            repo_type=self.repo_type,
-            private=self.private,
-            token=self.token,
-            exist_ok=self.exist_ok,
-            resource_group_id=self.resource_group_id,
-            space_sdk=self.space_sdk,
-        )
-        print(f"Successfully created {ANSI.bold(repo_url.repo_id)} on the Hub.")
-        print(f"Your repo is now available at {ANSI.bold(repo_url)}")
-
-
-class RepoTagCommand:
-    def __init__(self, args):
-        self.args = args
-        self.api = HfApi(token=getattr(args, "token", None))
-        self.repo_id = args.repo_id
-        self.repo_type = getattr(args, "repo_type", "model")
-        if self.repo_type not in REPO_TYPES:
-            print("Invalid repo --repo-type")
-            exit(1)
-
-
-class RepoTagCreateCommand(RepoTagCommand):
-    def run(self):
-        print(
-            f"You are about to create tag {ANSI.bold(str(self.args.tag))} on {self.repo_type} {ANSI.bold(self.repo_id)}"
-        )
-        try:
-            self.api.create_tag(
-                repo_id=self.repo_id,
-                tag=self.args.tag,
-                tag_message=getattr(self.args, "message", None),
-                revision=getattr(self.args, "revision", None),
-                repo_type=self.repo_type,
-            )
-        except RepositoryNotFoundError:
-            print(f"{self.repo_type.capitalize()} {ANSI.bold(self.repo_id)} not found.")
-            exit(1)
-        except RevisionNotFoundError:
-            print(f"Revision {ANSI.bold(str(getattr(self.args, 'revision', None)))} not found.")
-            exit(1)
-        except HfHubHTTPError as e:
-            if e.response.status_code == 409:
-                print(f"Tag {ANSI.bold(str(self.args.tag))} already exists on {ANSI.bold(self.repo_id)}")
-                exit(1)
-            raise e
-        print(f"Tag {ANSI.bold(str(self.args.tag))} created on {ANSI.bold(self.repo_id)}")
-
-
-class RepoTagListCommand(RepoTagCommand):
-    def run(self):
-        try:
-            refs = self.api.list_repo_refs(
-                repo_id=self.repo_id,
-                repo_type=self.repo_type,
-            )
-        except RepositoryNotFoundError:
-            print(f"{self.repo_type.capitalize()} {ANSI.bold(self.repo_id)} not found.")
-            exit(1)
-        except HTTPError as e:
-            print(e)
-            print(ANSI.red(e.response.text))
-            exit(1)
-        if len(refs.tags) == 0:
-            print("No tags found")
-            exit(0)
-        print(f"Tags for {self.repo_type} {ANSI.bold(self.repo_id)}:")
-        for tag in refs.tags:
-            print(tag.name)
-
-
-class RepoTagDeleteCommand(RepoTagCommand):
-    def run(self):
-        print(f"You are about to delete tag {ANSI.bold(self.args.tag)} on {self.repo_type} {ANSI.bold(self.repo_id)}")
-        if not getattr(self.args, "yes", False):
-            choice = input("Proceed? [Y/n] ").lower()
-            if choice not in ("", "y", "yes"):
-                print("Abort")
-                exit()
-        try:
-            self.api.delete_tag(repo_id=self.repo_id, tag=self.args.tag, repo_type=self.repo_type)
-        except RepositoryNotFoundError:
-            print(f"{self.repo_type.capitalize()} {ANSI.bold(self.repo_id)} not found.")
-            exit(1)
-        except RevisionNotFoundError:
-            print(f"Tag {ANSI.bold(self.args.tag)} not found on {ANSI.bold(self.repo_id)}")
-            exit(1)
-        print(f"Tag {ANSI.bold(self.args.tag)} deleted on {ANSI.bold(self.repo_id)}")
+        ),
+    ] = None,
+) -> None:
+    api = get_hf_api(token=token)
+    repo_url = api.create_repo(
+        repo_id=repo_id,
+        repo_type=repo_type.value,
+        private=private,
+        token=token,
+        exist_ok=exist_ok,
+        resource_group_id=resource_group_id,
+        space_sdk=space_sdk,
+    )
+    print(f"Successfully created {ANSI.bold(repo_url.repo_id)} on the Hub.")
+    print(f"Your repo is now available at {ANSI.bold(repo_url)}")
+
+
+@tag_app.command("create", help="Create a tag for a repo.")
+def tag_create(
+    repo_id: RepoIdArg,
+    tag: Annotated[
+        str,
+        typer.Argument(
+            help="The name of the tag to create.",
+        ),
+    ],
+    message: Annotated[
+        Optional[str],
+        typer.Option(
+            "-m",
+            "--message",
+            help="The description of the tag to create.",
+        ),
+    ] = None,
+    revision: RevisionOpt = None,
+    token: TokenOpt = None,
+    repo_type: RepoTypeOpt = RepoType.model,
+) -> None:
+    repo_type_str = repo_type.value
+    api = get_hf_api(token=token)
+    print(f"You are about to create tag {ANSI.bold(tag)} on {repo_type_str} {ANSI.bold(repo_id)}")
+    try:
+        api.create_tag(repo_id=repo_id, tag=tag, tag_message=message, revision=revision, repo_type=repo_type_str)
+    except RepositoryNotFoundError:
+        print(f"{repo_type_str.capitalize()} {ANSI.bold(repo_id)} not found.")
+        raise typer.Exit(code=1)
+    except RevisionNotFoundError:
+        print(f"Revision {ANSI.bold(str(revision))} not found.")
+        raise typer.Exit(code=1)
+    except HfHubHTTPError as e:
+        if e.response.status_code == 409:
+            print(f"Tag {ANSI.bold(tag)} already exists on {ANSI.bold(repo_id)}")
+            raise typer.Exit(code=1)
+        raise e
+    print(f"Tag {ANSI.bold(tag)} created on {ANSI.bold(repo_id)}")
+
+
+@tag_app.command("list", help="List tags for a repo.")
+def tag_list(
+    repo_id: RepoIdArg,
+    token: TokenOpt = None,
+    repo_type: RepoTypeOpt = RepoType.model,
+) -> None:
+    repo_type_str = repo_type.value
+    api = get_hf_api(token=token)
+    try:
+        refs = api.list_repo_refs(repo_id=repo_id, repo_type=repo_type_str)
+    except RepositoryNotFoundError:
+        print(f"{repo_type_str.capitalize()} {ANSI.bold(repo_id)} not found.")
+        raise typer.Exit(code=1)
+    except HfHubHTTPError as e:
+        print(e)
+        print(ANSI.red(e.response.text))
+        raise typer.Exit(code=1)
+    if len(refs.tags) == 0:
+        print("No tags found")
+        raise typer.Exit(code=0)
+    print(f"Tags for {repo_type_str} {ANSI.bold(repo_id)}:")
+    for t in refs.tags:
+        print(t.name)
+
+
+@tag_app.command("delete", help="Delete a tag for a repo.")
+def tag_delete(
+    repo_id: RepoIdArg,
+    tag: Annotated[
+        str,
+        typer.Argument(
+            help="The name of the tag to delete.",
+        ),
+    ],
+    yes: Annotated[
+        bool,
+        typer.Option(
+            "-y",
+            "--yes",
+            help="Answer Yes to prompt automatically",
+        ),
+    ] = False,
+    token: TokenOpt = None,
+    repo_type: RepoTypeOpt = RepoType.model,
+) -> None:
+    repo_type_str = repo_type.value
+    print(f"You are about to delete tag {ANSI.bold(tag)} on {repo_type_str} {ANSI.bold(repo_id)}")
+    if not yes:
+        choice = input("Proceed? [Y/n] ").lower()
+        if choice not in ("", "y", "yes"):
+            print("Abort")
+            raise typer.Exit()
+    api = get_hf_api(token=token)
+    try:
+        api.delete_tag(repo_id=repo_id, tag=tag, repo_type=repo_type_str)
+    except RepositoryNotFoundError:
+        print(f"{repo_type_str.capitalize()} {ANSI.bold(repo_id)} not found.")
+        raise typer.Exit(code=1)
+    except RevisionNotFoundError:
+        print(f"Tag {ANSI.bold(tag)} not found on {ANSI.bold(repo_id)}")
+        raise typer.Exit(code=1)
+    print(f"Tag {ANSI.bold(tag)} deleted on {ANSI.bold(repo_id)}")

huggingface_hub/cli/repo_files.py

@@ -34,95 +34,61 @@ Usage:
     hf repo-files delete <repo_id> file.txt --revision=refs/pr/1 --repo-type=dataset
 """
 
-from argparse import _SubParsersAction
-from typing import List, Optional
+from typing import Annotated, Optional
+
+import typer
 
 from huggingface_hub import logging
-from huggingface_hub.commands import BaseHuggingfaceCLICommand
-from huggingface_hub.hf_api import HfApi
+
+from ._cli_utils import RepoIdArg, RepoType, RepoTypeOpt, RevisionOpt, TokenOpt, get_hf_api, typer_factory
 
 
 logger = logging.get_logger(__name__)
 
 
-class DeleteFilesSubCommand:
-    def __init__(self, args) -> None:
-        self.args = args
-        self.repo_id: str = args.repo_id
-        self.repo_type: Optional[str] = args.repo_type
-        self.revision: Optional[str] = args.revision
-        self.api: HfApi = HfApi(token=args.token, library_name="hf")
-        self.patterns: List[str] = args.patterns
-        self.commit_message: Optional[str] = args.commit_message
-        self.commit_description: Optional[str] = args.commit_description
-        self.create_pr: bool = args.create_pr
-        self.token: Optional[str] = args.token
-
-    def run(self) -> None:
-        logging.set_verbosity_info()
-        url = self.api.delete_files(
-            delete_patterns=self.patterns,
-            repo_id=self.repo_id,
-            repo_type=self.repo_type,
-            revision=self.revision,
-            commit_message=self.commit_message,
-            commit_description=self.commit_description,
-            create_pr=self.create_pr,
-        )
-        print(f"Files correctly deleted from repo. Commit: {url}.")
-        logging.set_verbosity_warning()
-
-
-class RepoFilesCommand(BaseHuggingfaceCLICommand):
-    @staticmethod
-    def register_subcommand(parser: _SubParsersAction):
-        repo_files_parser = parser.add_parser("repo-files", help="Manage files in a repo on the Hub.")
-        repo_files_subparsers = repo_files_parser.add_subparsers(
-            help="Action to execute against the files.",
-            required=True,
-        )
-        delete_subparser = repo_files_subparsers.add_parser(
-            "delete",
-            help="Delete files from a repo on the Hub",
-        )
-        delete_subparser.set_defaults(func=lambda args: DeleteFilesSubCommand(args))
-        delete_subparser.add_argument(
-            "repo_id", type=str, help="The ID of the repo to manage (e.g. `username/repo-name`)."
-        )
-        delete_subparser.add_argument(
-            "patterns",
-            nargs="+",
-            type=str,
+repo_files_cli = typer_factory(help="Manage files in a repo on the Hub.")
+
+
+@repo_files_cli.command("delete")
+def repo_files_delete(
+    repo_id: RepoIdArg,
+    patterns: Annotated[
+        list[str],
+        typer.Argument(
             help="Glob patterns to match files to delete.",
-        )
-        delete_subparser.add_argument(
-            "--repo-type",
-            choices=["model", "dataset", "space"],
-            default="model",
-            help="Type of the repo to upload to (e.g. `dataset`).",
-        )
-        delete_subparser.add_argument(
-            "--revision",
-            type=str,
-            help=(
-                "An optional Git revision to push to. It can be a branch name "
-                "or a PR reference. If revision does not"
-                " exist and `--create-pr` is not set, a branch will be automatically created."
-            ),
-        )
-        delete_subparser.add_argument(
-            "--commit-message", type=str, help="The summary / title / first line of the generated commit."
-        )
-        delete_subparser.add_argument(
-            "--commit-description", type=str, help="The description of the generated commit."
-        )
-        delete_subparser.add_argument(
-            "--create-pr", action="store_true", help="Whether to create a new Pull Request for these changes."
-        )
-        delete_subparser.add_argument(
-            "--token",
-            type=str,
-            help="A User Access Token generated from https://huggingface.co/settings/tokens",
-        )
-
-        repo_files_parser.set_defaults(func=RepoFilesCommand)
+        ),
+    ],
+    repo_type: RepoTypeOpt = RepoType.model,
+    revision: RevisionOpt = None,
+    commit_message: Annotated[
+        Optional[str],
+        typer.Option(
+            help="The summary / title / first line of the generated commit.",
+        ),
+    ] = None,
+    commit_description: Annotated[
+        Optional[str],
+        typer.Option(
+            help="The description of the generated commit.",
+        ),
+    ] = None,
+    create_pr: Annotated[
+        bool,
+        typer.Option(
+            help="Whether to create a new Pull Request for these changes.",
+        ),
+    ] = False,
+    token: TokenOpt = None,
+) -> None:
+    api = get_hf_api(token=token)
+    url = api.delete_files(
+        delete_patterns=patterns,
+        repo_id=repo_id,
+        repo_type=repo_type.value,
+        revision=revision,
+        commit_message=commit_message,
+        commit_description=commit_description,
+        create_pr=create_pr,
+    )
+    print(f"Files correctly deleted from repo. Commit: {url}.")
+    logging.set_verbosity_warning()

huggingface_hub/cli/system.py

@@ -18,35 +18,16 @@ Usage:
     hf version
 """
 
-from argparse import _SubParsersAction
-
 from huggingface_hub import __version__
 
 from ..utils import dump_environment_info
-from . import BaseHuggingfaceCLICommand
-
-
-class EnvironmentCommand(BaseHuggingfaceCLICommand):
-    def __init__(self, args):
-        self.args = args
-
-    @staticmethod
-    def register_subcommand(parser: _SubParsersAction):
-        env_parser = parser.add_parser("env", help="Print information about the environment.")
-        env_parser.set_defaults(func=EnvironmentCommand)
-
-    def run(self) -> None:
-        dump_environment_info()
 
 
-class VersionCommand(BaseHuggingfaceCLICommand):
-    def __init__(self, args):
-        self.args = args
+def env() -> None:
+    """Print information about the environment."""
+    dump_environment_info()
 
-    @staticmethod
-    def register_subcommand(parser: _SubParsersAction):
-        version_parser = parser.add_parser("version", help="Print information about the hf version.")
-        version_parser.set_defaults(func=VersionCommand)
 
-    def run(self) -> None:
-        print(f"huggingface_hub version: {__version__}")
+def version() -> None:
+    """Print CLI version."""
+    print(f"huggingface_hub version: {__version__}")