hfutils 0.2.11__tar.gz → 0.3.0__tar.gz

{hfutils-0.2.11/hfutils.egg-info → hfutils-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hfutils
-Version: 0.2.11
+Version: 0.3.0
 Summary: Useful utilities for huggingface
 Home-page: https://github.com/deepghs/hfutils
 Author: narugo1992
@@ -20,13 +20,14 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: hbutils>=0.9.3
+Requires-Dist: hbutils>=0.10.0
 Requires-Dist: huggingface_hub>=0.23
 Requires-Dist: tqdm
 Requires-Dist: requests
 Requires-Dist: click>=7
 Requires-Dist: tzlocal
 Requires-Dist: natsort
+Requires-Dist: urlobject
 Provides-Extra: doc
 Requires-Dist: Jinja2>=3.0.0; extra == "doc"
 Requires-Dist: sphinx>=3.2.0; extra == "doc"

{hfutils-0.2.11 → hfutils-0.3.0}/hfutils/config/meta.py

@@ -7,7 +7,7 @@ Overview:
 __TITLE__ = 'hfutils'
 
 #: Version of this project.
-__VERSION__ = '0.2.11'
+__VERSION__ = '0.3.0'
 
 #: Short description of the project, will be included in ``setup.py``.
 __DESCRIPTION__ = 'Useful utilities for huggingface'

{hfutils-0.2.11 → hfutils-0.3.0}/hfutils/entry/cli.py

@@ -1,8 +1,10 @@
+from .clone import _add_clone_subcommand
 from .dispatch import hfutilcli
 from .download import _add_download_subcommand
 from .index import _add_index_subcommand
 from .ls import _add_ls_subcommand
 from .ls_repo import _add_ls_repo_subcommand
+from .rollback import _add_rollback_subcommand
 from .upload import _add_upload_subcommand
 from .whoami import _add_whoami_subcommand
 
@@ -13,6 +15,8 @@ _DECORATORS = [
     _add_whoami_subcommand,
     _add_ls_repo_subcommand,
     _add_index_subcommand,
+    _add_rollback_subcommand,
+    _add_clone_subcommand,
 ]
 
 cli = hfutilcli

hfutils-0.3.0/hfutils/entry/clone.py

@@ -0,0 +1,79 @@
+import logging
+import os.path
+import re
+from typing import Optional
+
+import click
+
+from .base import CONTEXT_SETTINGS
+from ..operate.base import REPO_TYPES, RepoTypeTyping
+from ..repository import hf_hub_clone
+from ..utils import ColoredFormatter
+
+
+def _add_clone_subcommand(cli: click.Group) -> click.Group:
+    """
+    Add a 'clone' subcommand to the given CLI group.
+
+    This function defines a 'clone' command that allows users to clone repositories
+    from the Hugging Face Hub.
+
+    :param cli: The Click group to which the 'clone' command will be added.
+    :type cli: click.Group
+    :return: The modified Click group with the 'clone' command added.
+    :rtype: click.Group
+    """
+
+    @cli.command('clone', help='Clone remote repository with permission (if possible).\n\n'
+                               'Set environment $HF_TOKEN to use your own access token.',
+                 context_settings=CONTEXT_SETTINGS)
+    @click.option('-r', '--repository', 'repo_id', type=str, required=True,
+                  help='Repository to clone.')
+    @click.option('-t', '--type', 'repo_type', type=click.Choice(REPO_TYPES), default='dataset',
+                  help='Type of the HuggingFace repository.', show_default=True)
+    @click.option('-R', '--revision', 'revision', type=str, default='main',
+                  help='Revision of repository.', show_default=True)
+    @click.option('-o', '--output_dir', 'output_dir', type=str, default=None,
+                  help='Output directory to clone the repository')
+    @click.option('--no_lfs', 'no_lfs', type=bool, is_flag=True, default=False,
+                  help='Do not download LFS files, just download their pointers.')
+    @click.option('-d', '--max_depth', 'max_depth', type=int, default=None,
+                  help='Max commit depth to clone. Useful when this repository has large numbers of commits.')
+    def clone(repo_id: str, repo_type: RepoTypeTyping, revision: str, output_dir: Optional[str] = None,
+              no_lfs: bool = False, max_depth: Optional[int] = None):
+        """
+        Clone a repository from the Hugging Face Hub.
+
+        This function sets up logging and then calls hf_hub_clone to perform the actual cloning.
+
+        :param repo_id: The ID of the repository to clone.
+        :param repo_type: The type of the repository (e.g., 'dataset', 'model').
+        :param revision: The revision of the repository to clone.
+        :param output_dir: The directory where the repository will be cloned. If None, uses the repo's short name.
+        :param no_lfs: If True, don't download LFS files, just their pointers.
+        :param max_depth: The maximum depth of commits to clone.
+        """
+        # Set up logging
+        logger = logging.getLogger()
+        logger.setLevel(logging.INFO)
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(ColoredFormatter())
+        logger.addHandler(console_handler)
+
+        # Determine the output directory
+        short_name = list(filter(bool, re.split(r'[/\\]+', repo_id)))[-1]
+        output_dir = os.path.abspath(output_dir or short_name)
+        if os.path.dirname(output_dir):
+            os.makedirs(os.path.dirname(output_dir), exist_ok=True)
+
+        # Perform the clone operation
+        hf_hub_clone(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=revision,
+            dst_dir=output_dir,
+            no_lfs=no_lfs,
+            max_depth=max_depth,
+        )
+
+    return cli

hfutils-0.3.0/hfutils/entry/rollback.py

@@ -0,0 +1,61 @@
+import logging
+
+import click
+
+from .base import CONTEXT_SETTINGS
+from ..operate.base import REPO_TYPES, RepoTypeTyping
+from ..repository import hf_hub_rollback
+from ..utils import ColoredFormatter
+
+
+def _add_rollback_subcommand(cli: click.Group) -> click.Group:
+    """
+    Add a 'rollback' subcommand to the given CLI group.
+
+    This function defines a 'rollback' command that allows users to rollback
+    repositories on the Hugging Face Hub to a specific commit.
+
+    :param cli: The Click group to which the 'rollback' command will be added.
+    :type cli: click.Group
+    :return: The modified Click group with the 'rollback' command added.
+    :rtype: click.Group
+    """
+
+    @cli.command('rollback', help='Rollback remote repository to a specific commit.\n\n'
+                                  'Set environment $HF_TOKEN to use your own access token.',
+                 context_settings=CONTEXT_SETTINGS)
+    @click.option('-r', '--repository', 'repo_id', type=str, required=True,
+                  help='Repository to rollback.')
+    @click.option('-t', '--type', 'repo_type', type=click.Choice(REPO_TYPES), default='dataset',
+                  help='Type of the HuggingFace repository.', show_default=True)
+    @click.option('-R', '--revision', 'revision', type=str, default='main',
+                  help='Revision of repository.', show_default=True)
+    @click.option('-c', '--commit_id', 'rollback_to_commit_id', type=str, required=True,
+                  help='Rollback back to this commit id.')
+    def rollback(repo_id: str, repo_type: RepoTypeTyping, revision: str, rollback_to_commit_id: str):
+        """
+        Rollback a repository on the Hugging Face Hub to a specific commit.
+
+        This function sets up logging and then calls hf_hub_rollback to perform the actual rollback.
+
+        :param repo_id: The ID of the repository to rollback.
+        :param repo_type: The type of the repository (e.g., 'dataset', 'model').
+        :param revision: The revision of the repository to rollback.
+        :param rollback_to_commit_id: The commit ID to rollback to.
+        """
+        # Set up logging
+        logger = logging.getLogger()
+        logger.setLevel(logging.INFO)
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(ColoredFormatter())
+        logger.addHandler(console_handler)
+
+        # Perform the rollback operation
+        hf_hub_rollback(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=revision,
+            rollback_to=rollback_to_commit_id,
+        )
+
+    return cli

{hfutils-0.2.11 → hfutils-0.3.0}/hfutils/operate/upload.py

@@ -1,13 +1,17 @@
 import datetime
+import logging
+import math
 import os.path
 import re
+import time
 from typing import Optional, List
 
+from hbutils.string import plural_word
 from huggingface_hub import CommitOperationAdd, CommitOperationDelete
 
 from .base import RepoTypeTyping, get_hf_client, list_files_in_repository, _IGNORE_PATTERN_UNSET
 from ..archive import get_archive_type, archive_pack
-from ..utils import walk_files, TemporaryDirectory
+from ..utils import walk_files, TemporaryDirectory, tqdm
 
 
 def upload_file_to_file(local_file, repo_id: str, file_in_repo: str,
@@ -77,11 +81,14 @@ def upload_directory_as_archive(local_directory, repo_id: str, archive_in_repo:
 _PATH_SEP = re.compile(r'[/\\]+')
 
 
-def upload_directory_as_directory(local_directory, repo_id: str, path_in_repo: str,
-                                  repo_type: RepoTypeTyping = 'dataset', revision: str = 'main',
-                                  message: Optional[str] = None, time_suffix: bool = True,
-                                  clear: bool = False, ignore_patterns: List[str] = _IGNORE_PATTERN_UNSET,
-                                  hf_token: Optional[str] = None):
+def upload_directory_as_directory(
+        local_directory, repo_id: str, path_in_repo: str,
+        repo_type: RepoTypeTyping = 'dataset', revision: str = 'main',
+        message: Optional[str] = None, time_suffix: bool = True,
+        clear: bool = False, ignore_patterns: List[str] = _IGNORE_PATTERN_UNSET,
+        hf_token: Optional[str] = None, operation_chunk_size: Optional[int] = None,
+        upload_timespan: float = 5.0,
+):
     """
     Upload a local directory and its files to a specified path in a Hugging Face repository.
 
@@ -105,6 +112,24 @@ def upload_directory_as_directory(local_directory, repo_id: str, path_in_repo: s
     :type ignore_patterns: List[str]
     :param hf_token: Huggingface token for API client, use ``HF_TOKEN`` variable if not assigned.
     :type hf_token: str, optional
+    :param operation_chunk_size: Chunk size of the operations. All the operations will be
+        seperated into multiple commits when this is set.
+    :type operation_chunk_size: Optional[int]
+    :param upload_timespan: Upload minimal time interval when chunked uploading enabled.
+    :type upload_timespan: float
+
+    .. note::
+        When `operation_chunk_size` is set, multiple commits will be created. When some commits failed,
+        it will roll back to the startup commit, using :func:`hfutils.repository.hf_hub_rollback` function..
+
+    .. warning::
+        When `operation_chunk_size` is set, multiple commits will be created. But HuggingFace's repository
+        api cannot guarantee the atomic feature of your data. So **this function is not thread-safe**.
+
+    .. note::
+        The rate limit of HuggingFace repository commit creation is approximately 120 commits / hour.
+        So if you really have large number of chunks to create, please set the `upload_timespan` to a value
+        no less than `30.0` to make sure your uploading will not be rate-limited.
     """
     hf_client = get_hf_client(hf_token)
     if clear:
@@ -135,10 +160,58 @@ def upload_directory_as_directory(local_directory, repo_id: str, path_in_repo: s
     if time_suffix:
         commit_message = f'{commit_message}, on {current_time}'
 
-    hf_client.create_commit(
-        repo_id=repo_id,
-        repo_type=repo_type,
-        revision=revision,
-        operations=operations,
-        commit_message=commit_message,
-    )
+    if operation_chunk_size:
+        initial_commit_id = hf_client.list_repo_commits(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=revision
+        )[0].commit_id
+
+        last_upload_at = None
+        try:
+            total_chunks = int(math.ceil(len(operations) / operation_chunk_size))
+            for chunk_id in tqdm(range(total_chunks), desc='Chunked Commits'):
+                operation_chunk = operations[chunk_id * operation_chunk_size:(chunk_id + 1) * operation_chunk_size]
+
+                # sleep for the given time
+                if last_upload_at:
+                    sleep_time = last_upload_at + upload_timespan - time.time()
+                    if sleep_time > 0:
+                        logging.info(f'Sleep for {sleep_time:.1f}s due to the timespan limitation ...')
+                        time.sleep(sleep_time)
+
+                last_upload_at = time.time()
+                logging.info(f'Uploading chunk #{chunk_id + 1}, '
+                             f'with {plural_word(len(operation_chunk), "operation")} ...')
+                hf_client.create_commit(
+                    repo_id=repo_id,
+                    repo_type=repo_type,
+                    revision=revision,
+                    operations=operation_chunk,
+                    commit_message=f'[Chunk #{chunk_id + 1}/{total_chunks}] {commit_message}',
+                )
+
+
+        except Exception:
+            from ..repository import hf_hub_rollback
+
+            logging.error(f'Error found when executing chunked uploading, '
+                          f'revision {revision!r} will rollback to {initial_commit_id!r} ...')
+            hf_hub_rollback(
+                repo_id=repo_id,
+                repo_type=repo_type,
+                revision=revision,
+                rollback_to=initial_commit_id,
+                hf_token=hf_token,
+            )
+
+            raise
+
+    else:
+        hf_client.create_commit(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=revision,
+            operations=operations,
+            commit_message=commit_message,
+        )

hfutils-0.3.0/hfutils/repository/__init__.py

@@ -0,0 +1,7 @@
+"""
+Overview:
+    Some git-based operations.
+"""
+from .base import hf_hub_repo_url
+from .clone import hf_hub_clone
+from .rollback import hf_hub_rollback

hfutils-0.3.0/hfutils/repository/base.py

@@ -0,0 +1,81 @@
+"""
+This module provides utility functions for working with Hugging Face Hub repositories and Git.
+
+It includes functions to:
+
+1. Generate Hugging Face Hub repository URLs.
+2. Check Git and Git LFS installations.
+
+The module uses the `git_info` function from the `hbutils.system` package and constants from `huggingface_hub`.
+"""
+
+from typing import Optional
+
+from hbutils.system import git_info
+from huggingface_hub.constants import ENDPOINT
+
+from ..utils.path import RepoTypeTyping
+
+
+def hf_hub_repo_url(repo_id: str, repo_type: RepoTypeTyping = 'dataset', endpoint: Optional[str] = None) -> str:
+    """
+    Generate a Hugging Face Hub repository URL.
+
+    :param repo_id: The repository ID.
+    :type repo_id: str
+    :param repo_type: The type of repository. Can be 'model', 'dataset', or 'space'. Defaults to 'dataset'.
+    :type repo_type: RepoTypeTyping
+    :param endpoint: The Hugging Face Hub endpoint. If None, uses the default ENDPOINT.
+    :type endpoint: Optional[str]
+
+    :return: The full URL for the specified Hugging Face Hub repository.
+    :rtype: str
+
+    :raises ValueError: If an unknown repository type is provided.
+
+    :usage:
+        >>> hf_hub_repo_url('username/repo', 'model')
+        'https://huggingface.co/username/repo'
+        >>> hf_hub_repo_url('username/dataset', 'dataset')
+        'https://huggingface.co/datasets/username/dataset'
+    """
+    endpoint = endpoint or ENDPOINT
+    if repo_type == 'model':
+        return f'{endpoint}/{repo_id}'
+    elif repo_type == 'dataset':
+        return f'{endpoint}/datasets/{repo_id}'
+    elif repo_type == 'space':
+        return f'{endpoint}/spaces/{repo_id}'
+    else:
+        raise ValueError(f'Unknown repository type - {repo_type!r}.')
+
+
+def _check_git(requires_lfs: bool = True) -> str:
+    """
+    Check Git and Git LFS installations.
+
+    This function checks if Git is installed and, optionally, if Git LFS is installed.
+    The results are cached for improved performance.
+
+    :param requires_lfs: Whether to check for Git LFS installation. Defaults to True.
+    :type requires_lfs: bool
+
+    :return: The path to the Git executable.
+    :rtype: str
+
+    :raises EnvironmentError: If Git is not installed or if Git LFS is required but not installed.
+
+    :usage:
+        >>> _check_git()
+        '/usr/bin/git'
+        >>> _check_git(requires_lfs=False)
+        '/usr/bin/git'
+    """
+    info = git_info()
+    if not info['installed']:
+        raise EnvironmentError('Git not installed.')
+    else:
+        if requires_lfs and not info['lfs']['installed']:
+            raise EnvironmentError('Git lfs not installed.')
+        else:
+            return info['exec']

hfutils-0.3.0/hfutils/repository/clone.py

@@ -0,0 +1,87 @@
+"""
+This module provides functionality to clone Hugging Face Hub repositories using Git.
+
+It includes a function to clone a repository from Hugging Face Hub to a local directory,
+with options for authentication, repository type, revision, and other Git clone parameters.
+"""
+
+import copy
+import logging
+import os
+import subprocess
+import sys
+from typing import Optional
+
+from huggingface_hub.errors import LocalTokenNotFoundError
+from urlobject import URLObject
+
+from .base import hf_hub_repo_url, _check_git
+from ..operate import get_hf_client
+from ..utils.path import RepoTypeTyping
+
+
+def hf_hub_clone(repo_id: str, dst_dir: str,
+                 repo_type: RepoTypeTyping = 'dataset', revision: str = 'main',
+                 endpoint: Optional[str] = None, hf_token: Optional[str] = None,
+                 silent: bool = False, no_lfs: bool = False, max_depth: Optional[int] = None):
+    """
+    Clone a repository from Hugging Face Hub.
+
+    :param repo_id: The ID of the repository to clone.
+    :type repo_id: str
+    :param dst_dir: The local directory to clone the repository into.
+    :type dst_dir: str
+    :param repo_type: The type of the repository ('dataset', 'model', or 'space'). Defaults to 'dataset'.
+    :type repo_type: RepoTypeTyping
+    :param revision: The specific revision to clone. Defaults to 'main'.
+    :type revision: str
+    :param endpoint: The Hugging Face Hub endpoint. If None, uses the default endpoint.
+    :type endpoint: Optional[str]
+    :param hf_token: The Hugging Face authentication token. If None, attempts to use stored credentials.
+    :type hf_token: Optional[str]
+    :param silent: If True, suppresses command output. Defaults to False.
+    :type silent: bool
+    :param no_lfs: If True, skips downloading of LFS files. Defaults to False.
+    :type no_lfs: bool
+    :param max_depth: The maximum number of commits to fetch. If None, fetches all commits.
+    :type max_depth: Optional[int]
+
+    :raises subprocess.CalledProcessError: If the Git clone command fails.
+
+    :usage:
+        >>> hf_hub_clone('username/repo', '/path/to/local/dir', repo_type='model', revision='v1.0')
+    """
+    _git = _check_git(requires_lfs=not no_lfs)
+    hf_client = get_hf_client(hf_token)
+    try:
+        username = hf_client.whoami()['name']
+    except LocalTokenNotFoundError:
+        username = None  # anonymous mode
+
+    clone_url = URLObject(hf_hub_repo_url(
+        repo_id=repo_id,
+        repo_type=repo_type,
+        endpoint=endpoint,
+    ))
+    if username:
+        clone_url = clone_url.with_username(username).with_password(hf_client.token)
+    clone_url = str(clone_url)
+
+    command = [_git, 'clone', '-b', revision]
+    if max_depth is not None:
+        command.extend(['--depth', str(max_depth)])
+    command.extend([clone_url, dst_dir])
+    logging.info(f'Cloning repository with command {command!r} ...')
+    with open(os.devnull, 'w') as nf:
+        envs = copy.deepcopy(os.environ)
+        if no_lfs:
+            envs['GIT_LFS_SKIP_SMUDGE'] = '1'
+        envs['GIT_TERMINAL_PROMPT'] = '0'
+        process = subprocess.run(
+            args=command,
+            stdout=nf if silent else sys.stdout,
+            stderr=nf if silent else sys.stderr,
+            env=envs,
+            bufsize=0 if not silent else -1,
+        )
+        process.check_returncode()

hfutils-0.3.0/hfutils/repository/rollback.py

@@ -0,0 +1,102 @@
+"""
+This module provides functionality to rollback a Hugging Face Hub repository to a specific commit.
+
+It includes a function to clone a repository, reset it to a specified commit, and force push the changes back to the remote repository.
+"""
+
+import logging
+import os.path
+import subprocess
+import sys
+from typing import Optional
+
+from .base import _check_git
+from .clone import hf_hub_clone
+from ..utils import TemporaryDirectory
+from ..utils.path import RepoTypeTyping
+
+
+def hf_hub_rollback(repo_id: str, rollback_to: str,
+                    repo_type: RepoTypeTyping = 'dataset', revision: str = 'main',
+                    endpoint: Optional[str] = None, hf_token: Optional[str] = None, silent: bool = False):
+    """
+    Rollback a Hugging Face Hub repository to a specific commit.
+
+    This function clones the repository, resets it to the specified commit, and force pushes the changes back to the remote.
+
+    :param repo_id: The ID of the repository to rollback.
+    :type repo_id: str
+    :param rollback_to: The commit hash or reference to rollback to.
+    :type rollback_to: str
+    :param repo_type: The type of the repository ('dataset', 'model', or 'space'). Defaults to 'dataset'.
+    :type repo_type: RepoTypeTyping
+    :param revision: The branch or tag to clone. Defaults to 'main'.
+    :type revision: str
+    :param endpoint: The Hugging Face Hub endpoint. If None, uses the default endpoint.
+    :type endpoint: Optional[str]
+    :param hf_token: The Hugging Face authentication token. If None, attempts to use stored credentials.
+    :type hf_token: Optional[str]
+    :param silent: If True, suppresses command output. Defaults to False.
+    :type silent: bool
+
+    :raises subprocess.CalledProcessError: If any Git command fails during the process.
+
+    :usage:
+        >>> hf_hub_rollback('username/repo', 'abc123', repo_type='model')
+
+    .. note::
+
+        This function performs the following steps:
+
+        1. Checks for Git installation (without LFS requirement).
+        2. Creates a temporary directory for the operation.
+        3. Clones the specified repository into the temporary directory.
+        4. Resets the repository to the specified commit using 'git reset --hard'.
+        5. Force pushes the changes back to the remote repository.
+
+    .. warning::
+        This operation can overwrite remote history and can not be cancelled. Use with caution.
+    """
+    _git = _check_git(requires_lfs=False)
+    with TemporaryDirectory() as td, open(os.devnull, 'w') as nf:
+        envs = {
+            **os.environ,
+            'GIT_LFS_SKIP_SMUDGE': '1',
+            'GIT_TERMINAL_PROMPT': '0',
+        }
+
+        repo_dir = os.path.join(td, 'repo')
+        hf_hub_clone(
+            repo_id=repo_id,
+            dst_dir=repo_dir,
+            repo_type=repo_type,
+            revision=revision,
+            endpoint=endpoint,
+            hf_token=hf_token,
+            silent=silent,
+            no_lfs=True,
+        )
+
+        reset_command = [_git, 'reset', '--hard', rollback_to]
+        logging.info(f'Git resetting with command {reset_command!r} ...')
+        process = subprocess.run(
+            args=reset_command,
+            stdout=nf if silent else sys.stdout,
+            stderr=nf if silent else sys.stderr,
+            env=envs,
+            bufsize=0 if not silent else -1,
+            cwd=repo_dir,
+        )
+        process.check_returncode()
+
+        push_command = [_git, 'push', '-f']
+        logging.info(f'Git pushing with command {push_command!r} ...')
+        process = subprocess.run(
+            args=push_command,
+            stdout=nf if silent else sys.stdout,
+            stderr=nf if silent else sys.stderr,
+            env=envs,
+            bufsize=0 if not silent else -1,
+            cwd=repo_dir,
+        )
+        process.check_returncode()

{hfutils-0.2.11 → hfutils-0.3.0/hfutils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hfutils
-Version: 0.2.11
+Version: 0.3.0
 Summary: Useful utilities for huggingface
 Home-page: https://github.com/deepghs/hfutils
 Author: narugo1992
@@ -20,13 +20,14 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: hbutils>=0.9.3
+Requires-Dist: hbutils>=0.10.0
 Requires-Dist: huggingface_hub>=0.23
 Requires-Dist: tqdm
 Requires-Dist: requests
 Requires-Dist: click>=7
 Requires-Dist: tzlocal
 Requires-Dist: natsort
+Requires-Dist: urlobject
 Provides-Extra: doc
 Requires-Dist: Jinja2>=3.0.0; extra == "doc"
 Requires-Dist: sphinx>=3.2.0; extra == "doc"

{hfutils-0.2.11 → hfutils-0.3.0}/hfutils.egg-info/SOURCES.txt

@@ -30,11 +30,13 @@ hfutils/config/meta.py
 hfutils/entry/__init__.py
 hfutils/entry/base.py
 hfutils/entry/cli.py
+hfutils/entry/clone.py
 hfutils/entry/dispatch.py
 hfutils/entry/download.py
 hfutils/entry/index.py
 hfutils/entry/ls.py
 hfutils/entry/ls_repo.py
+hfutils/entry/rollback.py
 hfutils/entry/upload.py
 hfutils/entry/whoami.py
 hfutils/index/__init__.py
@@ -47,6 +49,10 @@ hfutils/operate/base.py
 hfutils/operate/download.py
 hfutils/operate/upload.py
 hfutils/operate/validate.py
+hfutils/repository/__init__.py
+hfutils/repository/base.py
+hfutils/repository/clone.py
+hfutils/repository/rollback.py
 hfutils/utils/__init__.py
 hfutils/utils/binary.py
 hfutils/utils/download.py

{hfutils-0.2.11 → hfutils-0.3.0}/hfutils.egg-info/requires.txt

@@ -1,10 +1,11 @@
-hbutils>=0.9.3
+hbutils>=0.10.0
 huggingface_hub>=0.23
 tqdm
 requests
 click>=7
 tzlocal
 natsort
+urlobject
 
 [7z]
 py7zr

{hfutils-0.2.11 → hfutils-0.3.0}/requirements.txt

@@ -1,7 +1,8 @@
-hbutils>=0.9.3
+hbutils>=0.10.0
 huggingface_hub>=0.23
 tqdm
 requests
 click>=7
 tzlocal
-natsort
+natsort
+urlobject