hfutils 0.4.3__tar.gz → 0.5.0__tar.gz

{hfutils-0.4.3/hfutils.egg-info → hfutils-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hfutils
-Version: 0.4.3
+Version: 0.5.0
 Summary: Useful utilities for huggingface
 Home-page: https://github.com/deepghs/hfutils
 Author: narugo1992
@@ -30,13 +30,32 @@ Requires-Dist: natsort
 Requires-Dist: urlobject
 Requires-Dist: fsspec>=2024
 Requires-Dist: random_user_agent
+Provides-Extra: rar
+Requires-Dist: rarfile; extra == "rar"
 Provides-Extra: build
 Requires-Dist: pyinstaller<5,>=4.7; extra == "build"
 Requires-Dist: setuptools<70; extra == "build"
+Provides-Extra: transfer
+Requires-Dist: hf-transfer; extra == "transfer"
 Provides-Extra: 7z
 Requires-Dist: py7zr; extra == "7z"
-Provides-Extra: rar
-Requires-Dist: rarfile; extra == "rar"
+Provides-Extra: test
+Requires-Dist: coverage>=5; extra == "test"
+Requires-Dist: mock>=4.0.3; extra == "test"
+Requires-Dist: flake8~=3.5; extra == "test"
+Requires-Dist: testfixtures>=6.18.5; extra == "test"
+Requires-Dist: pytest~=6.2.5; extra == "test"
+Requires-Dist: pytest-cov~=3.0.0; extra == "test"
+Requires-Dist: pytest-mock~=3.6.1; extra == "test"
+Requires-Dist: pytest-xdist>=1.34.0; extra == "test"
+Requires-Dist: pytest-rerunfailures~=10.2; extra == "test"
+Requires-Dist: pytest-timeout~=2.0.2; extra == "test"
+Requires-Dist: pytest-benchmark~=3.4.0; extra == "test"
+Requires-Dist: easydict<2,>=1.7; extra == "test"
+Requires-Dist: testtools>=2; extra == "test"
+Requires-Dist: where>=1.0.2; extra == "test"
+Requires-Dist: responses>=0.20.0; extra == "test"
+Requires-Dist: natsort; extra == "test"
 Provides-Extra: doc
 Requires-Dist: Jinja2>=3.0.0; extra == "doc"
 Requires-Dist: sphinx>=3.2.0; extra == "doc"
@@ -57,25 +76,6 @@ Requires-Dist: ipykernel>=6.15; extra == "doc"
 Requires-Dist: py-cpuinfo>=8.0.0; extra == "doc"
 Requires-Dist: click>=7.0.0; extra == "doc"
 Requires-Dist: pandas; extra == "doc"
-Provides-Extra: test
-Requires-Dist: coverage>=5; extra == "test"
-Requires-Dist: mock>=4.0.3; extra == "test"
-Requires-Dist: flake8~=3.5; extra == "test"
-Requires-Dist: testfixtures>=6.18.5; extra == "test"
-Requires-Dist: pytest~=6.2.5; extra == "test"
-Requires-Dist: pytest-cov~=3.0.0; extra == "test"
-Requires-Dist: pytest-mock~=3.6.1; extra == "test"
-Requires-Dist: pytest-xdist>=1.34.0; extra == "test"
-Requires-Dist: pytest-rerunfailures~=10.2; extra == "test"
-Requires-Dist: pytest-timeout~=2.0.2; extra == "test"
-Requires-Dist: pytest-benchmark~=3.4.0; extra == "test"
-Requires-Dist: easydict<2,>=1.7; extra == "test"
-Requires-Dist: testtools>=2; extra == "test"
-Requires-Dist: where>=1.0.2; extra == "test"
-Requires-Dist: responses>=0.20.0; extra == "test"
-Requires-Dist: natsort; extra == "test"
-Provides-Extra: transfer
-Requires-Dist: hf-transfer; extra == "transfer"
 
 # hfutils
 

{hfutils-0.4.3 → hfutils-0.5.0}/hfutils/archive/base.py

@@ -1,3 +1,15 @@
+"""
+This module provides functionality for handling archive files in various formats.
+
+It includes functions for registering custom archive types, packing directories into archives,
+unpacking archives, and determining archive types based on file extensions. The module supports
+a flexible system for working with different archive formats through a registration mechanism.
+
+.. note::
+    This module uses a global dictionary to store registered archive types, so it's
+    important to register custom types before using the packing and unpacking functions.
+"""
+
 import os.path
 import warnings
 from typing import List, Dict, Tuple, Callable, Optional
@@ -9,14 +21,27 @@ def register_archive_type(name: str, exts: List[str], fn_pack: Callable, fn_unpa
     """
     Register a custom archive type with associated file extensions and packing/unpacking functions.
 
-    :param name: The name of the archive type.
+    This function allows users to add support for new archive types by providing the necessary
+    information and functions to handle the archive format.
+
+    :param name: The name of the archive type (e.g., 'zip', 'tar').
     :type name: str
-    :param exts: A list of file extensions associated with the archive type.
+    :param exts: A list of file extensions associated with the archive type (e.g., ['.zip']).
     :type exts: List[str]
     :param fn_pack: The packing function that takes a directory and an archive filename as input and creates an archive.
     :type fn_pack: Callable
     :param fn_unpack: The unpacking function that takes an archive filename and a directory as input and extracts the archive.
     :type fn_unpack: Callable
+    :raises ValueError: If no file extensions are provided for the archive type.
+
+    Example:
+        >>> def custom_pack(directory, archive_file, **kwargs):
+        ...     # Custom packing logic here
+        ...     pass
+        >>> def custom_unpack(archive_file, directory, **kwargs):
+        ...     # Custom unpacking logic here
+        ...     pass
+        >>> register_archive_type('custom', ['.cst'], custom_pack, custom_unpack)
     """
     if len(exts) == 0:
         raise ValueError(f'At least one extension name for archive type {name!r} should be provided.')
@@ -27,12 +52,17 @@ def get_archive_extname(type_name: str) -> str:
     """
     Get the file extension associated with a registered archive type.
 
+    This function returns the first (primary) file extension associated with the given archive type.
+
     :param type_name: The name of the archive type.
     :type type_name: str
-
     :return: The file extension associated with the archive type.
     :rtype: str
     :raises ValueError: If the archive type is not registered.
+
+    Example:
+        >>> get_archive_extname('zip')
+        '.zip'
     """
     if type_name in _KNOWN_ARCHIVE_TYPES:
         exts, _, _ = _KNOWN_ARCHIVE_TYPES[type_name]
@@ -41,23 +71,29 @@ def get_archive_extname(type_name: str) -> str:
         raise ValueError(f'Unknown archive type - {type_name!r}.')
 
 
-def archive_pack(type_name: str, directory: str, archive_file: str, silent: bool = False, clear: bool = False):
+def archive_pack(type_name: str, directory: str, archive_file: str,
+                 pattern: Optional[str] = None, silent: bool = False, clear: bool = False):
     """
     Pack a directory into an archive file using the specified archive type.
 
+    This function creates an archive of the specified type containing the contents of the given directory.
+
     :param type_name: The name of the archive type.
     :type type_name: str
     :param directory: The directory to pack.
     :type directory: str
     :param archive_file: The filename of the resulting archive.
     :type archive_file: str
+    :param pattern: A pattern to filter files for inclusion in the archive (optional).
+    :type pattern: str, optional
     :param silent: If True, suppress warnings during the packing process.
     :type silent: bool
     :param clear: If True, remove existing files when packing.
     :type clear: bool
+    :raises ValueError: If the archive type is not registered.
 
-    :return: The path to the created archive file.
-    :rtype: str
+    Example:
+        >>> archive_pack('zip', '/path/to/directory', '/path/to/archive.zip', pattern='*.txt')
     """
     exts, fn_pack, _ = _KNOWN_ARCHIVE_TYPES[type_name]
     if not any(os.path.normcase(archive_file).endswith(extname) for extname in exts):
@@ -65,19 +101,25 @@ def archive_pack(type_name: str, directory: str, archive_file: str, silent: bool
                       f'but file name {archive_file!r} is assigned. '
                       f'We strongly recommend using a regular extension name for the archive file.')
 
-    return fn_pack(directory, archive_file, silent=silent, clear=clear)
+    return fn_pack(directory, archive_file, pattern=pattern, silent=silent, clear=clear)
 
 
 def get_archive_type(archive_file: str) -> str:
     """
     Determine the archive type based on the file extension.
 
+    This function examines the file extension of the given archive file and returns the
+    corresponding archive type name.
+
     :param archive_file: The filename of the archive.
     :type archive_file: str
-
     :return: The name of the archive type.
     :rtype: str
     :raises ValueError: If the file extension is not associated with any registered archive type.
+
+    Example:
+        >>> get_archive_type('/path/to/archive.tar.gz')
+        'gztar'
     """
     archive_file = os.path.normcase(archive_file)
     for type_name, (exts, _, _) in _KNOWN_ARCHIVE_TYPES.items():
@@ -91,17 +133,20 @@ def archive_unpack(archive_file: str, directory: str, silent: bool = False, pass
     """
     Unpack an archive file into a directory using the specified archive type.
 
+    This function extracts the contents of the given archive file into the specified directory.
+
     :param archive_file: The filename of the archive.
     :type archive_file: str
     :param directory: The directory to unpack the contents into.
     :type directory: str
     :param silent: If True, suppress warnings during the unpacking process.
     :type silent: bool
-    :param password: The password to extract the archive file.
+    :param password: The password to extract the archive file (optional).
     :type password: str, optional
+    :raises ValueError: If the archive type is not recognized.
 
-    :return: The path to the unpacked directory.
-    :rtype: str
+    Example:
+        >>> archive_unpack('/path/to/archive.zip', '/path/to/extract')
     """
     type_name = get_archive_type(archive_file)
     _, _, fn_unpack = _KNOWN_ARCHIVE_TYPES[type_name]

hfutils-0.5.0/hfutils/archive/rar.py

@@ -0,0 +1,61 @@
+"""
+This module provides functionality for handling RAR archives.
+
+It includes functions for unpacking RAR files and a placeholder for packing (which is not supported).
+The module uses the 'rarfile' library for RAR file operations.
+
+.. note::
+    The 'rarfile' library is optional. If not installed, RAR functionality will be limited.
+"""
+
+import os
+from typing import Optional
+
+from .base import register_archive_type
+
+try:
+    import rarfile
+except ImportError:  # pragma: no cover
+    rarfile = None
+
+
+def _rar_pack(directory, zip_file, pattern: Optional[str] = None, silent: bool = False, clear: bool = False):
+    """
+    Placeholder function for RAR packing (not supported).
+
+    :param directory: The directory to pack.
+    :param zip_file: The output RAR file.
+    :param pattern: Optional pattern for file selection.
+    :type pattern: str, optional
+    :param silent: If True, suppress output. Defaults to False.
+    :type silent: bool
+    :param clear: If True, clear the directory after packing. Defaults to False.
+    :type clear: bool
+    :raises RuntimeError: Always raised as RAR packing is not supported.
+    """
+    _ = directory, zip_file, pattern, silent, clear
+    raise RuntimeError('RAR format packing is not supported.')
+
+
+def _rar_unpack(rar_file, directory, silent: bool = False, password: Optional[str] = None):
+    """
+    Unpack a RAR file to a specified directory.
+
+    :param rar_file: The RAR file to unpack.
+    :param directory: The directory to unpack the RAR file into.
+    :param silent: If True, suppress output. Defaults to False.
+    :type silent: bool
+    :param password: Optional password for encrypted RAR files.
+    :type password: str, optional
+    """
+    _ = silent
+    directory = os.fspath(directory)
+    os.makedirs(directory, exist_ok=True)
+    with rarfile.RarFile(rar_file, 'r') as zf:
+        if password is not None:
+            zf.setpassword(password)
+        zf.extractall(directory)
+
+
+if rarfile is not None:
+    register_archive_type('rar', ['.rar'], _rar_pack, _rar_unpack)

hfutils-0.5.0/hfutils/archive/sevenz.py

@@ -0,0 +1,68 @@
+"""
+This module provides functionality for handling 7z archive files.
+
+It includes functions for packing and unpacking 7z archives, and registers
+the 7z archive type if the py7zr library is available.
+
+.. note::
+    `py7zr` is required for 7z archive operations. If not available, 7z functionality will be disabled.
+"""
+
+import os
+from typing import Optional
+
+from .base import register_archive_type
+from ..utils import tqdm, walk_files
+
+try:
+    import py7zr
+except ImportError:  # pragma: no cover
+    py7zr = None
+
+
+def _7z_pack(directory, sz_file, pattern: Optional[str] = None, silent: bool = False, clear: bool = False):
+    """
+    Pack files from a directory into a 7z archive.
+
+    :param directory: The source directory containing files to be packed.
+    :type directory: str
+    :param sz_file: The path to the output 7z file.
+    :type sz_file: str
+    :param pattern: Optional file pattern to filter files for packing.
+    :type pattern: str, optional
+    :param silent: If True, suppress progress output.
+    :type silent: bool, optional
+    :param clear: If True, remove source files after packing.
+    :type clear: bool, optional
+    """
+    with py7zr.SevenZipFile(sz_file, 'w') as zf:
+        progress = tqdm(walk_files(directory, pattern=pattern), silent=silent, desc=f'Packing {directory!r} ...')
+        for file in progress:
+            progress.set_description(file)
+            zf.write(os.path.join(directory, file), file)
+            if clear:
+                os.remove(os.path.join(directory, file))
+
+
+def _7z_unpack(sz_file, directory, silent: bool = False, password: Optional[str] = None):
+    """
+    Unpack files from a 7z archive to a directory.
+
+    :param sz_file: The path to the 7z file to be unpacked.
+    :type sz_file: str
+    :param directory: The destination directory for unpacked files.
+    :type directory: str
+    :param silent: If True, suppress progress output (currently unused).
+    :type silent: bool, optional
+    :param password: Optional password for encrypted archives.
+    :type password: str, optional
+    """
+    _ = silent
+    directory = os.fspath(directory)
+    os.makedirs(directory, exist_ok=True)
+    with py7zr.SevenZipFile(sz_file, 'r', password=password) as zf:
+        zf.extractall(directory)
+
+
+if py7zr is not None:
+    register_archive_type('7z', ['.7z'], _7z_pack, _7z_unpack)

{hfutils-0.4.3 → hfutils-0.5.0}/hfutils/archive/tar.py

@@ -1,3 +1,13 @@
+"""
+This module provides functionality for working with tar archive files.
+
+It includes functions for packing and unpacking tar archives with various compression options.
+The module also registers different tar archive types based on the available compression libraries.
+
+.. note::
+    Some compression methods may not be available depending on the system's installed libraries.
+"""
+
 import copy
 import os.path
 import tarfile
@@ -28,7 +38,25 @@ except ImportError:
 CompressTyping = Literal['', 'gzip', 'bzip2', 'xz']
 
 
-def _tarfile_pack(directory, tar_file, compress: CompressTyping = "gzip", silent: bool = False, clear: bool = False):
+def _tarfile_pack(directory, tar_file, pattern: Optional[str] = None,
+                  compress: CompressTyping = "gzip", silent: bool = False, clear: bool = False):
+    """
+    Pack a directory into a tar archive file with optional compression.
+
+    :param directory: The directory to pack.
+    :type directory: str
+    :param tar_file: The name of the tar file to create.
+    :type tar_file: str
+    :param pattern: Optional file pattern to filter files for packing.
+    :type pattern: str, optional
+    :param compress: Compression method to use ('', 'gzip', 'bzip2', 'xz').
+    :type compress: CompressTyping
+    :param silent: If True, suppress progress output.
+    :type silent: bool
+    :param clear: If True, remove packed files from the source directory.
+    :type clear: bool
+    :raises ValueError: If an unsupported compression method is specified.
+    """
     if compress is None:
         tar_compression = ''
     elif compress == 'gzip':
@@ -42,7 +70,7 @@ def _tarfile_pack(directory, tar_file, compress: CompressTyping = "gzip", silent
                          "supported : {0}".format(compress))
 
     with tarfile.open(tar_file, f'w|{tar_compression}') as tar:
-        progress = tqdm(walk_files(directory), silent=silent, desc=f'Packing {directory!r} ...')
+        progress = tqdm(walk_files(directory, pattern=pattern), silent=silent, desc=f'Packing {directory!r} ...')
         for file in progress:
             progress.set_description(file)
             tar.add(os.path.join(directory, file), file)
@@ -51,6 +79,20 @@ def _tarfile_pack(directory, tar_file, compress: CompressTyping = "gzip", silent
 
 
 def _tarfile_unpack(tar_file, directory, silent: bool = False, numeric_owner=False, password: Optional[str] = None):
+    """
+    Unpack a tar archive file into a directory.
+
+    :param tar_file: The tar file to unpack.
+    :type tar_file: str
+    :param directory: The directory to unpack the files into.
+    :type directory: str
+    :param silent: If True, suppress progress output.
+    :type silent: bool
+    :param numeric_owner: If True, use numeric owner (UID, GID) instead of names.
+    :type numeric_owner: bool
+    :param password: Ignored for tar files (included for compatibility with other archive types).
+    :type password: str, optional
+    """
     if password is not None:
         warnings.warn('Password is not supported in tar archive files.\n'
                       'So assigned password will be ignored.')
@@ -82,6 +124,7 @@ def _tarfile_unpack(tar_file, directory, silent: bool = False, numeric_owner=Fal
             tar.chmod(tarinfo, dirpath)
 
 
+# Register various tar archive types based on available compression libraries
 register_archive_type('tar', ['.tar'], partial(_tarfile_pack, compress=None), _tarfile_unpack)
 if _ZLIB_SUPPORTED:
     register_archive_type('gztar', ['.tar.gz', '.tgz'], partial(_tarfile_pack, compress='gzip'), _tarfile_unpack)

hfutils-0.5.0/hfutils/archive/zip.py

@@ -0,0 +1,73 @@
+"""
+This module provides functionality for working with ZIP archives.
+
+It includes functions for packing directories into ZIP files and unpacking ZIP files into directories.
+The module also registers the ZIP archive type if zlib compression is supported.
+"""
+
+import os.path
+import zipfile
+from typing import Optional
+
+from .base import register_archive_type
+from ..utils import tqdm, walk_files
+
+try:
+    import zlib
+
+    del zlib
+    _ZLIB_SUPPORTED = True
+except ImportError:
+    _ZLIB_SUPPORTED = False
+
+
+def _zip_pack(directory, zip_file, pattern: Optional[str] = None, silent: bool = False, clear: bool = False):
+    """
+    Pack a directory into a ZIP file.
+
+    :param directory: The directory to pack.
+    :type directory: str
+    :param zip_file: The path to the output ZIP file.
+    :type zip_file: str
+    :param pattern: Optional file pattern to filter files for packing.
+    :type pattern: str, optional
+    :param silent: If True, suppress progress output.
+    :type silent: bool
+    :param clear: If True, remove original files after packing.
+    :type clear: bool
+    """
+    with zipfile.ZipFile(zip_file, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        progress = tqdm(walk_files(directory, pattern=pattern), silent=silent, desc=f'Packing {directory!r} ...')
+        for file in progress:
+            progress.set_description(file)
+            zf.write(os.path.join(directory, file), file)
+            if clear:
+                os.remove(os.path.join(directory, file))
+
+
+def _zip_unpack(zip_file, directory, silent: bool = False, password: Optional[str] = None):
+    """
+    Unpack a ZIP file into a directory.
+
+    :param zip_file: The path to the ZIP file to unpack.
+    :type zip_file: str
+    :param directory: The directory to unpack the ZIP file into.
+    :type directory: str
+    :param silent: If True, suppress progress output.
+    :type silent: bool
+    :param password: Optional password for encrypted ZIP files.
+    :type password: str, optional
+    """
+    directory = os.fspath(directory)
+    os.makedirs(directory, exist_ok=True)
+    with zipfile.ZipFile(zip_file, 'r') as zf:
+        if password is not None:
+            zf.setpassword(password.encode(encoding='utf-8'))
+        progress = tqdm(zf.namelist(), silent=silent, desc=f'Unpacking {directory!r} ...')
+        for zipinfo in progress:
+            progress.set_description(zipinfo)
+            zf.extract(zipinfo, directory)
+
+
+if _ZLIB_SUPPORTED:
+    register_archive_type('zip', ['.zip'], _zip_pack, _zip_unpack)

{hfutils-0.4.3 → hfutils-0.5.0}/hfutils/config/meta.py

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

{hfutils-0.4.3 → hfutils-0.5.0}/hfutils/entry/cli.py

@@ -6,6 +6,7 @@ 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 .squash import _add_squash_subcommand
 from .tree import _add_tree_subcommand
 from .upload import _add_upload_subcommand
 from .whoami import _add_whoami_subcommand
@@ -21,6 +22,7 @@ _DECORATORS = [
     _add_clone_subcommand,
     _add_tree_subcommand,
     _add_ils_subcommand,
+    _add_squash_subcommand,
 ]
 
 cli = hfutilcli

{hfutils-0.4.3 → hfutils-0.5.0}/hfutils/entry/download.py

@@ -1,3 +1,15 @@
+"""
+This module provides functionality for downloading data from HuggingFace repositories.
+
+It includes a CLI command for downloading files, archives, or directories from HuggingFace,
+with various options for customization. The module also defines custom exceptions and
+utility functions to support the download process.
+
+Usage:
+    This module is typically used as part of a larger CLI application for
+    interacting with HuggingFace repositories.
+"""
+
 import os
 import warnings
 from typing import Optional
@@ -14,6 +26,12 @@ from ..utils import get_requests_session
 class NoRemotePathAssignedWithDownload(ClickErrorException):
     """
     Custom exception class for indicating that no remote path in the repository is assigned.
+
+    This exception is raised when a download is attempted without specifying a file,
+    archive, or directory to download from the repository.
+
+    :attribute exit_code: The exit code to be used when this exception is raised.
+    :type exit_code: int
     """
     exit_code = 0x11
 
@@ -22,9 +40,12 @@ def _add_download_subcommand(cli: click.Group) -> click.Group:
     """
     Add the 'download' subcommand to the CLI.
 
-    :param cli: The Click CLI application.
+    This function defines and adds the 'download' command to the given CLI group.
+    It sets up all the necessary options and implements the download functionality.
+
+    :param cli: The Click CLI application to which the download command will be added.
     :type cli: click.Group
-    :return: The modified Click CLI application.
+    :return: The modified Click CLI application with the download command added.
     :rtype: click.Group
     """
 
@@ -68,6 +89,10 @@ def _add_download_subcommand(cli: click.Group) -> click.Group:
         """
         Download data from HuggingFace repositories.
 
+        This function implements the core functionality of the download command.
+        It handles downloading individual files, archives, or entire directories
+        from HuggingFace repositories based on the provided options.
+
         :param repo_id: Repository to download from.
         :type repo_id: str
         :param repo_type: Type of the HuggingFace repository.
@@ -85,13 +110,17 @@ def _add_download_subcommand(cli: click.Group) -> click.Group:
         :param max_workers: Max workers to download
         :type max_workers: int
         :param password: Password for the archive file. Only applied when -a is used.
-        :type password: str, optional
+        :type password: Optional[str]
         :param wildcard: Wildcard for files to download. Only applied when -d is used.
-        :type password: str, optional
+        :type wildcard: Optional[str]
         :param soft_mode_when_check: Just check the size of the expected file when enabled. Default is False.
         :type soft_mode_when_check: bool
         :param tmpdir: Use custom temporary Directory.
-        :type tmpdir: str, optional
+        :type tmpdir: Optional[str]
+        :param show_all: Show all files, including hidden files.
+        :type show_all: bool
+
+        :raises NoRemotePathAssignedWithDownload: If no remote path in repository is assigned.
         """
         configure_http_backend(get_requests_session)
 

hfutils-0.5.0/hfutils/entry/squash.py

@@ -0,0 +1,71 @@
+"""
+This module provides a command-line interface (CLI) for managing Hugging Face repositories.
+It includes functionality to squash the history of a specified repository on Hugging Face.
+Users can specify the repository ID, type, revision, and commit message when executing the squash command.
+The module utilizes the Click library for creating the CLI and integrates with the Hugging Face Hub API.
+"""
+
+from typing import Optional
+
+import click
+from huggingface_hub import configure_http_backend
+
+from .base import CONTEXT_SETTINGS, command_wrap
+from ..operate.base import REPO_TYPES, RepoTypeTyping, get_hf_client
+from ..utils import get_requests_session, hf_fs_path
+
+
+def _add_squash_subcommand(cli: click.Group) -> click.Group:
+    """
+    Add a 'squash' subcommand to the provided CLI group.
+
+    This subcommand allows users to squash the commit history of a specified Hugging Face repository.
+    Users must provide the repository ID and can optionally specify the repository type, revision, and commit message.
+    The command configures the HTTP backend and uses the Hugging Face client to perform the squash operation.
+
+    :param cli: The click.Group instance to which the subcommand will be added.
+    :type cli: click.Group
+
+    :return: The updated click.Group instance with the 'squash' subcommand added.
+    :rtype: click.Group
+    """
+
+    @cli.command('squash', help='Squash Repository from HuggingFace.\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 upload to.')
+    @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('-m', '--message', 'message', type=str, default=None,
+                  help='Commit message for this operation.', show_default=True)
+    @command_wrap()
+    def squash(repo_id: str, repo_type: RepoTypeTyping, revision: str, message: Optional[str]):
+        """
+        Squash the commit history of the specified Hugging Face repository.
+
+        This function configures the HTTP backend, initializes the Hugging Face client,
+        and performs the squash operation on the repository. If no commit message is provided,
+        a default message is generated using the repository ID and type.
+
+        :param repo_id: The ID of the repository to squash.
+        :type repo_id: str
+        :param repo_type: The type of the Hugging Face repository (e.g., 'dataset', 'model').
+        :type repo_type: RepoTypeTyping
+        :param revision: The branch or revision of the repository to squash.
+        :type revision: str
+        :param message: Optional commit message for the squash operation.
+        :type message: Optional[str]
+        """
+        configure_http_backend(get_requests_session)
+        hf_client = get_hf_client()
+        hf_client.super_squash_history(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            branch=revision,
+            commit_message=message or f'Squash {hf_fs_path(repo_id=repo_id, repo_type=repo_type, filename="")!r}',
+        )
+
+    return cli