hfutils 0.3.8__tar.gz → 0.4.0__tar.gz

{hfutils-0.3.8/hfutils.egg-info → hfutils-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hfutils
-Version: 0.3.8
+Version: 0.4.0
 Summary: Useful utilities for huggingface
 Home-page: https://github.com/deepghs/hfutils
 Author: narugo1992

{hfutils-0.3.8 → hfutils-0.4.0}/hfutils/config/meta.py

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

{hfutils-0.3.8 → hfutils-0.4.0}/hfutils/entry/cli.py

@@ -5,6 +5,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 .tree import _add_tree_subcommand
 from .upload import _add_upload_subcommand
 from .whoami import _add_whoami_subcommand
 
@@ -17,6 +18,7 @@ _DECORATORS = [
     _add_index_subcommand,
     _add_rollback_subcommand,
     _add_clone_subcommand,
+    _add_tree_subcommand,
 ]
 
 cli = hfutilcli

{hfutils-0.3.8 → hfutils-0.4.0}/hfutils/entry/download.py

@@ -7,7 +7,7 @@ from huggingface_hub import configure_http_backend
 
 from .base import CONTEXT_SETTINGS, command_wrap, ClickErrorException
 from ..operate import download_file_to_file, download_archive_as_directory, download_directory_as_directory
-from ..operate.base import REPO_TYPES, RepoTypeTyping
+from ..operate.base import REPO_TYPES, RepoTypeTyping, _IGNORE_PATTERN_UNSET
 from ..utils import get_requests_session
 
 
@@ -55,12 +55,15 @@ def _add_download_subcommand(cli: click.Group) -> click.Group:
                   help='Just check the file size when validating the downloaded files.', show_default=True)
     @click.option('--tmpdir', 'tmpdir', type=str, default=None,
                   help='Use custom temporary Directory.', show_default=True)
+    @click.option('--all', 'show_all', is_flag=True, type=bool, default=False,
+                  help='Show all files, including hidden files.', show_default=True)
     @command_wrap()
     def download(
             repo_id: str, repo_type: RepoTypeTyping,
             file_in_repo: Optional[str], archive_in_repo: Optional[str], dir_in_repo: Optional[str],
             output_path: str, revision: str, max_workers: int,
-            password: Optional[str], wildcard: Optional[str], soft_mode_when_check: bool, tmpdir: Optional[str]
+            password: Optional[str], wildcard: Optional[str], soft_mode_when_check: bool, tmpdir: Optional[str],
+            show_all: bool = False,
     ):
         """
         Download data from HuggingFace repositories.
@@ -135,6 +138,7 @@ def _add_download_subcommand(cli: click.Group) -> click.Group:
                 silent=False,
                 max_workers=max_workers,
                 soft_mode_when_check=soft_mode_when_check,
+                ignore_patterns=_IGNORE_PATTERN_UNSET if not show_all else [],
             )
 
         else:

{hfutils-0.3.8 → hfutils-0.4.0}/hfutils/entry/ls.py

@@ -1,6 +1,5 @@
-import mimetypes
 import os.path
-from enum import Enum, unique
+import os.path
 from typing import Union, List
 
 import click
@@ -10,46 +9,7 @@ from huggingface_hub.hf_api import RepoFolder, RepoFile
 
 from .base import CONTEXT_SETTINGS
 from ..operate.base import REPO_TYPES, get_hf_client
-from ..utils import get_requests_session
-
-mimetypes.add_type('image/webp', '.webp')
-
-
-@unique
-class ListItemType(Enum):
-    """
-    Enum class representing different types of list items.
-    """
-
-    FILE = 0x1
-    FOLDER = 0x2
-    IMAGE = 0x3
-    ARCHIVE = 0x4
-    MODEL = 0x5
-    DATA = 0x6
-
-    @property
-    def render_color(self):
-        """
-        Get the render color based on the item type.
-
-        :return: The render color for the item type.
-        :rtype: str
-        """
-        if self == self.FILE:
-            return None
-        elif self == self.FOLDER:
-            return 'blue'
-        elif self == self.IMAGE:
-            return 'magenta'
-        elif self == self.ARCHIVE:
-            return 'red'
-        elif self == self.MODEL:
-            return 'green'
-        elif self == self.DATA:
-            return 'yellow'
-        else:
-            raise ValueError(f'Unknown type - {self!r}')  # pragma: no cover
+from ..utils import get_requests_session, FileItemType, get_file_type
 
 
 class ListItem:
@@ -66,22 +26,9 @@ class ListItem:
         self.item = item
         self.base_dir = base_dir
         if isinstance(item, RepoFolder):
-            self.type = ListItemType.FOLDER
+            self.type = FileItemType.FOLDER
         else:
-            mimetype, _ = mimetypes.guess_type(item.path)
-            _, ext = os.path.splitext(item.path)
-            self.type = ListItemType.FILE
-            if ext in {'.ckpt', '.pt', '.safetensors', '.onnx', '.model', '.h5', '.mlmodel',
-                       '.ftz', '.pb', '.pth', '.tflite'}:
-                self.type = ListItemType.MODEL
-            elif ext in {'.json', '.csv', '.tsv', '.arrow', '.bin', '.msgpack', '.npy', '.npz',
-                         '.parquet', '.pickle', '.pkl', '.wasm'}:
-                self.type = ListItemType.DATA
-            elif mimetype:
-                if 'image' in mimetype:
-                    self.type = ListItemType.IMAGE
-                elif mimetype.split('/', maxsplit=1)[-1] in {'zip', 'rar', 'x-tar', 'x-7z-compressed'}:
-                    self.type = ListItemType.ARCHIVE
+            self.type = get_file_type(item.path)
 
 
 def _add_ls_subcommand(cli: click.Group) -> click.Group:
@@ -154,7 +101,7 @@ def _add_ls_subcommand(cli: click.Group) -> click.Group:
             max_size_length = 0
             max_commit_info_length = 0
             for item in items:
-                if item.type == ListItemType.FOLDER:
+                if item.type == FileItemType.FOLDER:
                     size_text = '-'
                 else:
                     size_text = str(item.item.size)
@@ -164,8 +111,8 @@ def _add_ls_subcommand(cli: click.Group) -> click.Group:
                 max_commit_info_length = max(max_commit_info_length, len(commit_text))
 
             for item in items:
-                print('d' if item.type == ListItemType.FOLDER else '-', end='')
-                print('L' if item.type != ListItemType.FOLDER and item.item.lfs else '-', end='')
+                print('d' if item.type == FileItemType.FOLDER else '-', end='')
+                print('L' if item.type != FileItemType.FOLDER and item.item.lfs else '-', end='')
 
                 commit_text = (item.item.last_commit.title or '').splitlines(keepends=False)[0]
                 print(
@@ -174,7 +121,7 @@ def _add_ls_subcommand(cli: click.Group) -> click.Group:
                     end=''
                 )
 
-                if item.type == ListItemType.FOLDER:
+                if item.type == FileItemType.FOLDER:
                     size_text = '-'
                 else:
                     size_text = str(item.item.size)

hfutils-0.4.0/hfutils/entry/tree.py

@@ -0,0 +1,239 @@
+"""
+This module provides functionality for listing and displaying files from a HuggingFace repository in a tree-like structure.
+
+It includes functions for parsing repository paths, retrieving file information, and formatting the output as a tree.
+The module also defines a CLI command for easy interaction with the tree functionality.
+
+Key components:
+
+- TreeItem: A dataclass representing an item (file or folder) in the tree structure.
+- _get_tree: Function to retrieve the tree structure of files in a HuggingFace repository.
+- _add_tree_subcommand: Function to add the 'tree' subcommand to a Click CLI group.
+
+Usage:
+This module is typically used as part of a larger CLI application for interacting with HuggingFace repositories.
+The 'tree' command can be used to visualize the structure of files in a repository.
+"""
+
+import dataclasses
+import os
+import re
+from typing import Optional, List, Union
+
+import click
+from hbutils.string import format_tree
+from huggingface_hub import configure_http_backend
+from huggingface_hub.hf_api import RepoFile
+from natsort import natsorted
+
+from .base import CONTEXT_SETTINGS
+from ..operate.base import REPO_TYPES, list_files_in_repository, RepoTypeTyping, get_hf_client
+from ..utils import get_requests_session, hf_normpath, get_file_type, hf_fs_path, FileItemType
+
+
+@dataclasses.dataclass
+class TreeItem:
+    """
+    Represents an item (file or folder) in the tree structure.
+
+    :param name: The name of the item.
+    :type name: str
+    :param type_: The type of the item (file or folder).
+    :type type_: FileItemType
+    :param children: List of child items if this is a folder.
+    :type children: Optional[List[TreeItem]]
+    :param exist: Whether the item exists in the repository.
+    :type exist: bool
+
+    :ivar name: The name of the item.
+    :ivar type_: The type of the item.
+    :ivar children: List of child items.
+    :ivar exist: Existence status of the item.
+    """
+
+    name: str
+    type_: FileItemType
+    children: Optional[List['TreeItem']]
+    exist: bool = True
+
+    def get_name(self):
+        """
+        Get the formatted name of the item for display.
+
+        :return: Formatted name string with color and strike-through if applicable.
+        :rtype: str
+        """
+        return click.style(
+            self.name,
+            fg=self.type_.render_color if self.exist else None,
+            strikethrough=not self.exist,
+        ) + ('' if self.exist else ' <NOT EXIST>')
+
+    def get_children(self):
+        """
+        Get the children of this item if it's a folder.
+
+        :return: List of child items if folder, empty list otherwise.
+        :rtype: List[TreeItem]
+        """
+        return self.children if self.type_ == FileItemType.FOLDER else []
+
+
+def _get_tree(repo_id: str, repo_type: RepoTypeTyping, dir_in_repo: str,
+              revision: Optional[str] = None, show_all: bool = False) -> TreeItem:
+    """
+    Retrieve the tree structure of files in a HuggingFace repository.
+
+    :param repo_id: The ID of the repository.
+    :type repo_id: str
+    :param repo_type: The type of the repository.
+    :type repo_type: RepoTypeTyping
+    :param dir_in_repo: The directory in the repository to start from.
+    :type dir_in_repo: str
+    :param revision: The revision of the repository to use.
+    :type revision: Optional[str]
+    :param show_all: Whether to show hidden files.
+    :type show_all: bool
+
+    :return: The root TreeItem representing the directory structure.
+    :rtype: TreeItem
+    """
+    root = {}
+    for filepath in list_files_in_repository(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            subdir=dir_in_repo,
+            revision=revision,
+            ignore_patterns=[],
+    ):
+        filename = hf_normpath(os.path.relpath(filepath, dir_in_repo))
+        segments = re.split(r'[\\/]+', filename)
+        if any(segment.startswith('.') and segment != '.' for segment in segments) and not show_all:
+            continue
+
+        current_node = root
+        for i, segment in enumerate(segments):
+            if segment not in current_node:
+                if i == (len(segments) - 1):
+                    current_node[segment] = get_file_type(segment)
+                else:
+                    current_node[segment] = {}
+            current_node = current_node[segment]
+
+    root_name = hf_fs_path(
+        repo_id=repo_id,
+        repo_type=repo_type,
+        filename=dir_in_repo,
+        revision=revision,
+    )
+
+    def _recursion(cur_node: Union[dict, FileItemType], parent_name: str, is_exist: bool = False):
+        if isinstance(cur_node, dict):
+            return TreeItem(
+                name=parent_name,
+                type_=FileItemType.FOLDER,
+                children=[
+                    _recursion(cur_node=value, parent_name=name, is_exist=is_exist)
+                    for name, value in natsorted(cur_node.items())
+                ],
+                exist=is_exist,
+            )
+        else:
+            return TreeItem(
+                name=parent_name,
+                type_=cur_node,
+                children=[],
+                exist=is_exist,
+            )
+
+    exist = True
+    if not root:
+        hf_client = get_hf_client()
+        paths = hf_client.get_paths_info(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=revision,
+            paths=[dir_in_repo],
+        )
+        if len(paths) == 0:
+            exist = False
+        elif len(paths) == 1:
+            pathobj = paths[0]
+            if isinstance(pathobj, RepoFile):  # the subdir is a file
+                root = get_file_type(dir_in_repo)
+        else:
+            assert len(paths) == 1, \
+                f'Multiple path {dir_in_repo!r} found in repo {root_name!r}, ' \
+                f'this must be caused by HuggingFace API.'  # pragma: no cover
+
+    return _recursion(
+        cur_node=root,
+        parent_name=root_name,
+        is_exist=exist,
+    )
+
+
+def _add_tree_subcommand(cli: click.Group) -> click.Group:
+    """
+    Add the 'tree' subcommand to a Click CLI group.
+
+    This function defines a new 'tree' command that lists files from a HuggingFace repository
+    in a tree-like structure.
+
+    :param cli: The Click CLI group to add the command to.
+    :type cli: click.Group
+
+    :return: The modified CLI group with the 'tree' command added.
+    :rtype: click.Group
+
+    Usage:
+        This function is typically called when setting up a CLI application:
+
+        cli = click.Group()
+        cli = _add_tree_subcommand(cli)
+    """
+
+    @cli.command('tree', help='List files as a tree from HuggingFace repository.\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 download from.')
+    @click.option('-t', '--type', 'repo_type', type=click.Choice(REPO_TYPES), default='dataset',
+                  help='Type of the HuggingFace repository.', show_default=True)
+    @click.option('-d', '--directory', 'dir_in_repo', type=str, default=None,
+                  help='Directory in repository to download the full directory tree.')
+    @click.option('-R', '--revision', 'revision', type=str, default='main',
+                  help='Revision of repository.', show_default=True)
+    @click.option('-a', '--all', 'show_all', is_flag=True, type=bool, default=False,
+                  help='Show all files, including hidden files.', show_default=True)
+    def tree(repo_id: str, repo_type: RepoTypeTyping, dir_in_repo, revision: str, show_all: bool):
+        """
+        List files as a tree from a HuggingFace repository in a tree-like structure.
+
+        :param repo_id: The ID of the repository.
+        :type repo_id: str
+        :param repo_type: The type of the repository.
+        :type repo_type: RepoTypeTyping
+        :param dir_in_repo: The directory in the repository to start from.
+        :type dir_in_repo: str
+        :param revision: The revision of the repository to use.
+        :type revision: str
+        :param show_all: Whether to show hidden files.
+        :type show_all: bool
+        """
+        configure_http_backend(get_requests_session)
+
+        _tree = _get_tree(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            dir_in_repo=dir_in_repo or '.',
+            revision=revision,
+            show_all=show_all,
+        )
+        print(format_tree(
+            _tree,
+            format_node=TreeItem.get_name,
+            get_children=TreeItem.get_children,
+        ))
+
+    return cli

{hfutils-0.3.8 → hfutils-0.4.0}/hfutils/operate/download.py

@@ -1,3 +1,27 @@
+"""
+This module provides functions for downloading files and directories from Hugging Face repositories.
+
+It includes utilities for downloading individual files, archives, and entire directories,
+with support for concurrent downloads, retries, and progress tracking.
+
+The module interacts with the Hugging Face Hub API to fetch repository contents and
+download files, handling various repository types and revisions.
+
+Key features:
+
+- Download individual files from Hugging Face repositories
+- Download and extract archive files
+- Download entire directories with pattern matching and ignore rules
+- Concurrent downloads with configurable worker count
+- Retry mechanism for failed downloads
+- Progress tracking with tqdm
+- Support for different repository types (dataset, model, space)
+- Token-based authentication for accessing private repositories
+
+This module is particularly useful for managing and synchronizing local copies of
+Hugging Face repository contents, especially when dealing with large datasets or models.
+"""
+
 import logging
 import os.path
 import shutil
@@ -12,9 +36,50 @@ from ..archive import archive_unpack
 from ..utils import tqdm, TemporaryDirectory, hf_normpath
 
 
+def _raw_download_file(td: str, local_file: str, repo_id: str, file_in_repo: str,
+                       repo_type: RepoTypeTyping = 'dataset', revision: str = 'main',
+                       hf_token: Optional[str] = None):
+    """
+    Download a file from a Hugging Face repository to a temporary directory and then move it to the final location.
+
+    This internal function handles the actual download process using the Hugging Face Hub client.
+
+    :param td: Temporary directory path.
+    :type td: str
+    :param local_file: The final local file path where the downloaded file will be moved.
+    :type local_file: str
+    :param repo_id: The identifier of the repository.
+    :type repo_id: str
+    :param file_in_repo: The file path within the repository.
+    :type file_in_repo: str
+    :param repo_type: The type of the repository ('dataset', 'model', 'space').
+    :type repo_type: RepoTypeTyping
+    :param revision: The revision of the repository (e.g., branch, tag, commit hash).
+    :type revision: str
+    :param hf_token: Hugging Face token for API client.
+    :type hf_token: str, optional
+    """
+    hf_client = get_hf_client(hf_token=hf_token)
+    relative_filename = os.path.join(*file_in_repo.split("/"))
+    temp_path = os.path.join(td, relative_filename)
+    try:
+        hf_client.hf_hub_download(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            filename=hf_normpath(file_in_repo),
+            revision=revision,
+            local_dir=td,
+        )
+    finally:
+        if os.path.exists(temp_path):
+            if os.path.dirname(local_file):
+                os.makedirs(os.path.dirname(local_file), exist_ok=True)
+            shutil.move(temp_path, local_file)
+
+
 def download_file_to_file(local_file: str, repo_id: str, file_in_repo: str,
                           repo_type: RepoTypeTyping = 'dataset', revision: str = 'main',
-                          resume_download: bool = True, hf_token: Optional[str] = None):
+                          hf_token: Optional[str] = None):
     """
     Download a file from a Hugging Face repository and save it to a local file.
 
@@ -28,29 +93,19 @@ def download_file_to_file(local_file: str, repo_id: str, file_in_repo: str,
     :type repo_type: RepoTypeTyping
     :param revision: The revision of the repository (e.g., branch, tag, commit hash).
     :type revision: str
-    :param resume_download: Resume the existing download.
-    :type resume_download: bool
     :param hf_token: Huggingface token for API client, use ``HF_TOKEN`` variable if not assigned.
     :type hf_token: str, optional
     """
-    hf_client = get_hf_client(hf_token)
-    relative_filename = os.path.join(*file_in_repo.split("/"))
     with TemporaryDirectory() as td:
-        temp_path = os.path.join(td, relative_filename)
-        try:
-            hf_client.hf_hub_download(
-                repo_id=repo_id,
-                repo_type=repo_type,
-                filename=hf_normpath(file_in_repo),
-                revision=revision,
-                local_dir=td,
-                resume_download=resume_download,
-            )
-        finally:
-            if os.path.exists(temp_path):
-                if os.path.dirname(local_file):
-                    os.makedirs(os.path.dirname(local_file), exist_ok=True)
-                shutil.move(temp_path, local_file)
+        _raw_download_file(
+            td=td,
+            local_file=local_file,
+            repo_id=repo_id,
+            file_in_repo=file_in_repo,
+            repo_type=repo_type,
+            revision=revision,
+            hf_token=hf_token,
+        )
 
 
 def download_archive_as_directory(local_directory: str, repo_id: str, file_in_repo: str,
@@ -84,7 +139,7 @@ def download_directory_as_directory(
         local_directory: str, repo_id: str, dir_in_repo: str = '.', pattern: str = '**/*',
         repo_type: RepoTypeTyping = 'dataset', revision: str = 'main',
         silent: bool = False, ignore_patterns: List[str] = _IGNORE_PATTERN_UNSET,
-        resume_download: bool = True, max_workers: int = 8, max_retries: int = 5,
+        max_workers: int = 8, max_retries: int = 5,
         soft_mode_when_check: bool = False, hf_token: Optional[str] = None
 ):
     """
@@ -110,8 +165,6 @@ def download_directory_as_directory(
     :type max_workers: int
     :param max_retries: Max retry times when downloading. Default is ``5``.
     :type max_retries: int
-    :param resume_download: Resume the existing download.
-    :type resume_download: bool
     :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 hf_token: Huggingface token for API client, use ``HF_TOKEN`` variable if not assigned.
@@ -129,46 +182,46 @@ def download_directory_as_directory(
     progress = tqdm(files, silent=silent, desc=f'Downloading {dir_in_repo!r} ...')
 
     def _download_one_file(rel_file):
-        current_resume_download = resume_download
-        try:
-            dst_file = os.path.join(local_directory, rel_file)
-            file_in_repo = hf_normpath(f'{dir_in_repo}/{rel_file}')
-            if os.path.exists(dst_file) and is_local_file_ready(
-                    repo_id=repo_id,
-                    repo_type=repo_type,
-                    local_file=dst_file,
-                    file_in_repo=file_in_repo,
-                    revision=revision,
-                    hf_token=hf_token,
-                    soft_mode=soft_mode_when_check,
-            ):
-                logging.info(f'Local file {rel_file} is ready, download skipped.')
-            else:
-                tries = 0
-                while True:
-                    try:
-                        download_file_to_file(
-                            local_file=dst_file,
-                            repo_id=repo_id,
-                            file_in_repo=file_in_repo,
-                            repo_type=repo_type,
-                            revision=revision,
-                            resume_download=current_resume_download,
-                            hf_token=hf_token,
-                        )
-                    except requests.exceptions.RequestException as err:
-                        if tries < max_retries:
-                            tries += 1
-                            logging.warning(f'Download {rel_file!r} failed, retry ({tries}/{max_retries}) - {err!r}.')
-                            current_resume_download = True
+        with TemporaryDirectory() as td:
+            try:
+                dst_file = os.path.join(local_directory, rel_file)
+                file_in_repo = hf_normpath(f'{dir_in_repo}/{rel_file}')
+                if os.path.exists(dst_file) and is_local_file_ready(
+                        repo_id=repo_id,
+                        repo_type=repo_type,
+                        local_file=dst_file,
+                        file_in_repo=file_in_repo,
+                        revision=revision,
+                        hf_token=hf_token,
+                        soft_mode=soft_mode_when_check,
+                ):
+                    logging.info(f'Local file {rel_file} is ready, download skipped.')
+                else:
+                    tries = 0
+                    while True:
+                        try:
+                            _raw_download_file(
+                                td=td,
+                                local_file=dst_file,
+                                repo_id=repo_id,
+                                file_in_repo=file_in_repo,
+                                repo_type=repo_type,
+                                revision=revision,
+                                hf_token=hf_token,
+                            )
+                        except requests.exceptions.RequestException as err:
+                            if tries < max_retries:
+                                tries += 1
+                                logging.warning(
+                                    f'Download {rel_file!r} failed, retry ({tries}/{max_retries}) - {err!r}.')
+                            else:
+                                raise
                         else:
-                            raise
-                    else:
-                        break
+                            break
 
-            progress.update()
-        except Exception as err:
-            logging.error(f'Unexpected error when downloading {rel_file!r} - {err!r}')
+                progress.update()
+            except Exception as err:
+                logging.exception(f'Unexpected error when downloading {rel_file!r} - {err!r}')
 
     tp = ThreadPoolExecutor(max_workers=max_workers)
     for file in files:

{hfutils-0.3.8 → hfutils-0.4.0}/hfutils/utils/__init__.py

@@ -1,4 +1,6 @@
+from .archive import is_archive_or_compressed
 from .binary import is_binary_file
+from .data import is_data_file
 from .download import download_file
 from .logging import ColoredFormatter
 from .number import number_to_tag
@@ -6,4 +8,5 @@ from .path import hf_normpath, hf_fs_path, parse_hf_fs_path, HfFileSystemPath
 from .session import TimeoutHTTPAdapter, get_requests_session, get_random_ua
 from .temp import TemporaryDirectory
 from .tqdm_ import tqdm
+from .type_ import FileItemType, get_file_type
 from .walk import walk_files