absfuyu 5.0.0__py3-none-any.whl → 6.1.2__py3-none-any.whl

absfuyu/util/path.py

@@ -3,8 +3,8 @@ Absfuyu: Path
 -------------
 Path related
 
-Version: 5.0.0
-Date updated: 13/02/2025 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 
 Feature:
 --------
@@ -16,8 +16,17 @@ Feature:
 # ---------------------------------------------------------------------------
 __all__ = [
     # Main
+    "DirectoryBase",
     "Directory",
+    "ProjectDirInit",
     "SaveFileAs",
+    # Mixin
+    "DirectoryInfoMixin",
+    "DirectoryBasicOperationMixin",
+    "DirectoryArchiverMixin",
+    "DirectoryOrganizerMixin",
+    "DirectoryTreeMixin",
+    "DirectorySelectMixin",
     # Support
     "FileOrFolderWithModificationTime",
     "DirectoryInfo",
@@ -26,17 +35,157 @@ __all__ = [
 
 # Library
 # ---------------------------------------------------------------------------
+import json
 import os
 import re
 import shutil
+from collections.abc import Mapping
+from dataclasses import dataclass
 from datetime import datetime
 from functools import partial
 from pathlib import Path
-from typing import Any, Literal, NamedTuple
+from typing import Any, ClassVar, Final, Literal, NamedTuple, Self, TypedDict
 
-from absfuyu.core import versionadded
+from absfuyu.core.baseclass import BaseClass
+from absfuyu.core.decorator import add_subclass_methods_decorator
+from absfuyu.core.docstring import deprecated, versionadded, versionchanged
 from absfuyu.logger import logger
 
+# Template
+# ---------------------------------------------------------------------------
+ORGANIZE_TEMPLATE: dict[str, list[str]] = {
+    "Code": [
+        ".ps1",
+        ".py",
+        ".rs",
+        ".js",
+        ".c",
+        ".h",
+        ".cpp",
+        ".cs",
+        ".r",
+        ".cmd",
+        ".bat",
+        ".lua",
+    ],
+    "Comic": [".cbz", ".cbr", ".cb7", ".cbt", ".cba"],
+    "Compressed": [
+        ".7z",
+        ".zip",
+        ".rar",
+        ".apk",
+        ".cab",
+        ".tar",
+        ".tgz",
+        ".txz",
+        ".bz2",
+        ".gz",
+        ".lz",
+        ".lz4",
+        ".lzma",
+        ".xz",
+        ".zipx",
+        ".zst",
+    ],
+    "Documents": [".docx", ".doc", ".xls", ".xlsx", ".ppt", ".pptx", ".pdf", ".txt"],
+    "Ebook": [
+        ".epub",
+        ".mobi",
+        ".prc",
+        ".lrf",
+        ".lrx",
+        ".pdb",
+        ".azw",
+        ".azw3",
+        ".kf8",
+        ".kfx",
+        ".opf",
+    ],
+    "Music": [".mp3", ".flac", ".wav", ".m4a", ".wma", ".aac", ".alac", ".aiff"],
+    "OS": [".iso", ".dmg", ".wim"],
+    "Pictures": [
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".apng",
+        ".avif",
+        ".bmp",
+        ".gif",
+        ".jfif",
+        ".pjpeg",
+        ".pjp",
+        ".svg",
+        ".ico",
+        ".cur",
+        ".tif",
+        ".tiff",
+        ".webp",
+    ],
+    "Programs": [".exe", ".msi"],
+    "Video": [
+        ".3g2",
+        ".3gp",
+        ".avi",
+        ".flv",
+        ".m2ts",
+        ".m4v",
+        ".mkv",
+        ".mov",
+        ".mp4",
+        ".mpeg",
+        ".mpv",
+        ".mts",
+        ".ts",
+        ".vob",
+        ".webm",
+    ],
+    "Raw pictures": [
+        ".3fr",
+        ".ari",
+        ".arw",
+        ".bay",
+        ".braw",
+        ".crw",
+        ".cr2",
+        ".cr3",
+        ".cap",
+        ".data",
+        ".dcs",
+        ".dcr",
+        ".dng",
+        ".drf",
+        ".eip",
+        ".erf",
+        ".fff",
+        ".gpr",
+        ".iiq",
+        ".k25",
+        ".kdc",
+        ".mdc",
+        ".mef",
+        ".mos",
+        ".mrw",
+        ".nef",
+        ".nrw",
+        ".obm",
+        ".orf",
+        ".pef",
+        ".ptx",
+        ".pxn",
+        ".r3d",
+        ".raf",
+        ".raw",
+        ".rwl",
+        ".rw2",
+        ".rwz",
+        ".sr2",
+        ".srf",
+        ".srw",
+        ".tif",
+        ".x3f",
+    ],
+}
+
 
 # Support Class
 # ---------------------------------------------------------------------------
@@ -53,21 +202,40 @@ class FileOrFolderWithModificationTime(NamedTuple):
     modification_time: datetime
 
 
+@deprecated(
+    "5.1.0", reason="Support for ``DirectoryInfoMixin`` which is also deprecated"
+)
 @versionadded("3.3.0")
 class DirectoryInfo(NamedTuple):
     """
     Information of a directory
     """
 
-    files: int
-    folders: int
     creation_time: datetime
     modification_time: datetime
 
 
-# Class - Directory | version 3.4.0: Remake Directory into modular class
+# Class - Directory
 # ---------------------------------------------------------------------------
-class DirectoryBase:
+@add_subclass_methods_decorator
+class DirectoryBase(BaseClass):
+    """
+    Directory - Base
+
+    Parameters
+    ----------
+    source_path : str | Path
+        Source folder
+
+    create_if_not_exist : bool
+        Create directory when not exist,
+        by default ``False``
+    """
+
+    # Custom attribute
+    _METHOD_INCLUDE: ClassVar[bool] = True  # Include in DIR_METHODS
+    SUBCLASS_METHODS: ClassVar[dict[str, list[str]]] = {}
+
     def __init__(
         self,
         source_path: str | Path,
@@ -80,80 +248,53 @@ class DirectoryBase:
             Source folder
 
         create_if_not_exist : bool
-            Create directory when not exist
-            (Default: ``False``)
+            Create directory when not exist,
+            by default ``False``
         """
         self.source_path = Path(source_path)
-        if create_if_not_exist:
-            if not self.source_path.exists():
+        if not self.source_path.exists():
+            if create_if_not_exist:
                 self.source_path.mkdir(exist_ok=True, parents=True)
+            else:
+                raise FileNotFoundError("Directory not existed")
 
-    def __str__(self) -> str:
-        return self.source_path.__str__()
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}({self.source_path})"
-
-    def __format__(self, __format_spec: str) -> str:
-        """
-        Change format of an object.
-        Avaiable option: ``info``
-
-        Usage
-        -----
-        >>> print(f"{<object>:<format_spec>}")
-        >>> print(<object>.__format__(<format_spec>))
-        >>> print(format(<object>, <format_spec>))
-        """
-        # Show quick info
-        if __format_spec.lower().startswith("info"):
-            return self.quick_info().__repr__()
-
-        # No format spec
-        return self.__repr__()
-
-    # Everything
-    @property
-    @versionadded("3.3.0")
-    def everything(self) -> list[Path]:
-        """
-        Every folders and files in this Directory
-        """
-        return list(x for x in self.source_path.glob("**/*"))
 
-    @versionadded("3.3.0")
-    def _every_folder(self) -> list[Path]:
-        """
-        Every folders in this Directory
-        """
-        return list(x for x in self.source_path.glob("**/*") if x.is_dir())
+class DirectoryInfoMixin(DirectoryBase):
+    """
+    Directory - Info
 
-    @versionadded("3.3.0")
-    def _every_file(self) -> list[Path]:
-        """
-        Every folders in this Directory
-        """
-        return list(x for x in self.source_path.glob("**/*") if x.is_file())
+    - Quick info
+    """
 
-    # Quick information
+    @deprecated("5.1.0", reason="Not efficient")
     @versionadded("3.3.0")
     def quick_info(self) -> DirectoryInfo:
         """
         Quick information about this Directory
 
-        :rtype: DirectoryInfo
+        Returns
+        -------
+        DirectoryInfo
+            DirectoryInfo
         """
         source_stat: os.stat_result = self.source_path.stat()
         out = DirectoryInfo(
-            files=len(self._every_file()),
-            folders=len(self._every_folder()),
             creation_time=datetime.fromtimestamp(source_stat.st_ctime),
             modification_time=datetime.fromtimestamp(source_stat.st_mtime),
         )
         return out
 
 
-class DirectoryBasicOperation(DirectoryBase):
+class DirectoryBasicOperationMixin(DirectoryBase):
+    """
+    Directory - Basic operation
+
+    - Rename
+    - Copy
+    - Move
+    - Delete
+    """
+
     # Rename
     def rename(self, new_name: str) -> None:
         """
@@ -214,7 +355,7 @@ class DirectoryBasicOperation(DirectoryBase):
                 shutil.move(self.source_path, Path(dst))
             logger.debug(f"Moving to {dst}...DONE")
 
-        except shutil.Error as e:  # File already exists
+        except OSError as e:  # File already exists
             logger.error(e)
             logger.debug("Overwriting file...")
             if content_only:
@@ -316,31 +457,54 @@ class DirectoryBasicOperation(DirectoryBase):
         except Exception as e:
             logger.error(f"Removing {self.source_path}...FAILED\n{e}")
 
-    # Zip
+
+class DirectoryArchiverMixin(DirectoryBase):
+    """
+    Directory - Archiver/Compress
+
+    - Compress
+    - Decompress
+    - Register extra zip format <staticmethod>
+    """
+
+    @versionchanged("5.1.0", reason="Update funcionality (new parameter)")
     def compress(
-        self, *, format: Literal["zip", "tar", "gztar", "bztar", "xztar"] = "zip"
+        self,
+        format: Literal["zip", "tar", "gztar", "bztar", "xztar"] = "zip",
+        delete_after_compress: bool = False,
+        move_inside: bool = True,
     ) -> Path | None:
         """
         Compress the directory (Default: Create ``.zip`` file)
 
         Parameters
         ----------
-        format : Literal["zip", "tar", "gztar", "bztar", "xztar"]
+        format : Literal["zip", "tar", "gztar", "bztar", "xztar"], optional
+            By default ``"zip"``
             - ``zip``: ZIP file (if the ``zlib`` module is available).
             - ``tar``: Uncompressed tar file. Uses POSIX.1-2001 pax format for new archives.
             - ``gztar``: gzip'ed tar-file (if the ``zlib`` module is available).
             - ``bztar``: bzip2'ed tar-file (if the ``bz2`` module is available).
             - ``xztar``: xz'ed tar-file (if the ``lzma`` module is available).
 
+        delete_after_compress : bool, optional
+            Delete directory after compress, by default ``False``
+
+        move_inside : bool, optional
+            Move the commpressed file inside the directory,
+            by default ``True``
+
         Returns
         -------
         Path
             Compressed path
+
         None
             When fail to compress
         """
         logger.debug(f"Zipping {self.source_path}...")
         try:
+            # Zip
             # zip_name = self.source_path.parent.joinpath(self.source_path.name).__str__()
             # shutil.make_archive(zip_name, format=format, root_dir=self.source_path)
             zip_path = shutil.make_archive(
@@ -348,26 +512,117 @@ class DirectoryBasicOperation(DirectoryBase):
             )
             logger.debug(f"Zipping {self.source_path}...DONE")
             logger.debug(f"Path: {zip_path}")
+
+            # Del
+            if delete_after_compress:
+                move_inside = False
+                shutil.rmtree(self.source_path)
+
+            # Move
+            if move_inside:
+                zf = Path(zip_path)
+                _move_path = self.source_path.joinpath(zf.name)
+                if _move_path.exists():
+                    _move_path.unlink(missing_ok=True)
+                _move = zf.rename(_move_path)
+                return _move
+
             return Path(zip_path)
-        except Exception as e:
+        except (FileExistsError, OSError) as e:
             logger.error(f"Zipping {self.source_path}...FAILED\n{e}")
             return None
 
+    @staticmethod
+    @versionadded("5.1.0")
+    def register_extra_zip_format() -> None:
+        """This register extra extension for zipfile"""
+        extra_extension = [".zip", ".cbz"]
+        shutil.unregister_unpack_format("zip")
+        shutil.register_unpack_format(
+            "zip",
+            extra_extension,
+            shutil._unpack_zipfile,  # type: ignore
+            description="ZIP file",
+        )
 
-class DirectoryTree(DirectoryBase):
-    pass
+    @versionadded("5.1.0")
+    def decompress(
+        self,
+        format: Literal["zip", "tar", "gztar", "bztar", "xztar"] | None = None,
+        delete_after_done: bool = False,
+    ) -> None:
+        """
+        Decompress compressed file in directory (first level only)
 
+        Parameters
+        ----------
+        format : Literal["zip", "tar", "gztar", "bztar", "xztar"] | None, optional
+            By default ``None``
+            - ``zip``: ZIP file (if the ``zlib`` module is available).
+            - ``tar``: Uncompressed tar file. Uses POSIX.1-2001 pax format for new archives.
+            - ``gztar``: gzip'ed tar-file (if the ``zlib`` module is available).
+            - ``bztar``: bzip2'ed tar-file (if the ``bz2`` module is available).
+            - ``xztar``: xz'ed tar-file (if the ``lzma`` module is available).
+
+        delete_after_done : bool, optional
+            Delete compressed file when extracted, by default ``False``
+        """
+        # Register extra extension
+        self.register_extra_zip_format()
 
-class Directory(DirectoryBasicOperation, DirectoryTree):
+        # Decompress first level only
+        for path in self.source_path.glob("*"):
+            try:
+                shutil.unpack_archive(
+                    path, path.parent.joinpath(path.stem), format=format
+                )
+                if delete_after_done and path.is_file():
+                    path.unlink(missing_ok=True)
+            except OSError:
+                continue
+
+
+class DirectoryOrganizerMixin(DirectoryBase):
     """
-    Some shortcuts for directory
+    Directory - File organizer
 
-    - list_structure
-    - delete, rename, copy, move
-    - zip
-    - quick_info
+    - Organize
     """
 
+    @versionadded("5.3.0")
+    def organize(self, dirtemplate: dict[str, list[str]] | None = None) -> None:
+        """
+        Organize a directory.
+
+        Parameters
+        ----------
+        dirtemplate : dict[str, Collection[str]] | None, optional
+            | Template to move file to, by default ``None``.
+            | Example: {"Documents": [".txt", ".pdf", ...]}
+        """
+        if dirtemplate is None:
+            template = ORGANIZE_TEMPLATE
+        else:
+            template = dirtemplate
+
+        other_dir = self.source_path.joinpath("Others")
+        other_dir.mkdir(parents=True, exist_ok=True)
+
+        for path in self.source_path.iterdir():
+            if path.is_dir():
+                continue
+
+            for dir_name, suffixes in template.items():
+                if path.suffix.lower() in suffixes:
+                    move_path = self.source_path.joinpath(dir_name)
+                    move_path.mkdir(parents=True, exist_ok=True)
+                    path.rename(move_path.joinpath(path.name))
+                    break
+            else:
+                path.rename(other_dir.joinpath(path.name))
+
+
+class DirectoryTreeMixin(DirectoryBase):
     # Directory structure
     def _list_dir(self, *ignore: str) -> list[Path]:
         """
@@ -415,7 +670,7 @@ class Directory(DirectoryBasicOperation, DirectoryTree):
 
         Example:
         --------
-        >>> test = [Path(test_root/test_not_root), ...]
+        >>> test = [Path(test_root / test_not_root), ...]
         >>> Directory._split_dir(test)
         [[test_root, test_not_root], [...]...]
         """
@@ -504,10 +759,381 @@ class Directory(DirectoryBasicOperation, DirectoryTree):
         return self.list_structure("__pycache__", ".pyc")
 
 
+@versionadded("5.6.0")
+class DirectorySelectMixin(DirectoryBase):
+    """
+    Directory - File select
+
+    - Select all
+    """
+
+    def select_all(self, *file_type: str, recursive: bool = False) -> list[Path]:
+        """
+        Select all files
+
+        Parameters
+        ----------
+        file_type : str
+            File suffix to select
+
+        recursive : bool, optional
+            Include sub directories, by default ``False``
+
+        Returns
+        -------
+        list[Path]
+            Selected file paths
+        """
+        pattern = "**/*" if recursive else "*"
+        paths = [
+            x
+            for x in self.source_path.glob(pattern)
+            if x.is_file() and x.suffix.lower() in map(lambda x: x.lower(), file_type)
+        ]
+        return paths
+
+
+class Directory(
+    DirectoryTreeMixin,
+    DirectoryOrganizerMixin,
+    DirectoryArchiverMixin,
+    DirectoryBasicOperationMixin,
+    DirectorySelectMixin,
+    DirectoryInfoMixin,
+):
+    """
+    Some shortcuts for directory
+
+    Parameters
+    ----------
+    source_path : str | Path
+        Source folder
+
+    create_if_not_exist : bool
+        Create directory when not exist,
+        by default ``False``
+
+
+    Example:
+    --------
+    >>> # For a list of method
+    >>> Directory.SUBCLASS_METHODS
+    """
+
+    pass
+
+
+# Class - ProjectDirInit
+# ---------------------------------------------------------------------------
+class ProjectDirInitTemplate(TypedDict):
+    folders: list[str]
+    files: dict[str, Any]
+
+
+@dataclass(slots=True)
+class FileContent:
+    path: Path
+    content: str
+    overwrite: bool = False
+
+
+@versionadded("6.0.0")
+class ProjectDirInit(DirectoryBase):
+    """
+    Initialize and manage a project directory structure.
+
+    This class allows you to declaratively register folders and files,
+    then generate or clean them in a controlled way.
+
+    Attributes
+    ----------
+    source_path : Path
+        Root directory of the project.
+
+    auto_generate : bool
+        If True, folders/files are created immediately when added.
+
+    _folders : dict[str, Path]
+        Registered subfolders.
+
+    _files : dict[str, FileContent]
+        Registered files with content.
+    """
+
+    ENCODING: Final[str] = "utf-8"
+
+    def __init__(
+        self,
+        source_path: str | Path,
+        create_if_not_exist: bool = False,
+        *,
+        auto_generate: bool = False,
+    ) -> None:
+        """
+        Project directory
+
+        Parameters
+        ----------
+        source_path : str | Path
+            Root directory of the project.
+
+        create_if_not_exist : bool
+            Create the root directory if it does not exist, by default ``False``
+
+        auto_generate : bool, optional
+            Automatically create folders/files when calling add methods, by default ``False``
+        """
+
+        super().__init__(source_path, create_if_not_exist)
+
+        # This variable store sub folder/file paths
+        self.auto_generate = auto_generate
+        self._folders: dict[str, Path] = {}
+        self._files: dict[str, FileContent] = {}
+
+    # Register
+    # -----------------------------------------
+    def add_folder(self, name: str) -> Path:
+        """
+        Register a subfolder relative to the project root.
+
+        Parameters
+        ----------
+        name : str
+            Folder name
+
+        Returns
+        -------
+        Path
+            Absolute path to the registered folder.
+        """
+        # path = self.source_path.joinpath(name)
+        path = self.source_path / name
+
+        self._folders[name] = path
+        if self.auto_generate:
+            self._make_folder()
+
+        return path
+
+    def add_file(
+        self,
+        name: str,
+        content: str | None = None,
+        *,
+        overwrite: bool = False,
+    ) -> Path:
+        """
+        Register a file relative to the project root.
+
+        Parameters
+        ----------
+        name : str
+            File name
+
+        content : str | None, optional
+            File content, by default ``None``
+
+        overwrite : bool, optional
+            Overwrite file if it already exists, bt default ``False``
+
+        Returns
+        -------
+        Path
+            Absolute path to the registered file.
+        """
+        # path = self.source_path.joinpath(name)
+        path = self.source_path / name
+
+        # c = "" if content is None else content
+        # self._files[name] = FileContent(path, c)
+        self._files[name] = FileContent(
+            path=path,
+            content=content or "",
+            overwrite=overwrite,
+        )
+
+        if self.auto_generate:
+            self._make_file()
+
+        return path
+
+    # Generate
+    # -----------------------------------------
+    def _make_folder(self) -> None:
+        """
+        Generate folders in ``self._folders``
+        """
+        if len(self._folders) < 1:
+            return None
+
+        for x in self._folders.values():
+            if not x.exists():
+                x.mkdir(parents=True, exist_ok=True)
+
+    def _make_file(self) -> None:
+        """
+        Generate files in ``self._files``
+        """
+        if len(self._files) < 1:
+            return None
+
+        for x in self._files.values():
+            if x.path.exists() and not x.overwrite:
+                continue
+
+            # with x.path.open("w", encoding=self.ENCODING) as f:
+            #     f.write(x.content)
+            x.path.write_text(x.content, encoding=self.ENCODING)
+
+    def generate_project(self) -> None:
+        """
+        Generate all registered folders and files.
+        """
+        self._make_folder()
+        self._make_file()
+
+    # Clean
+    # -----------------------------------------
+    def clean_up(self, *, remove_root: bool = False) -> None:
+        """
+        Remove generated folders and files.
+
+        Parameters
+        ----------
+        remove_root : bool, optional
+            If ``True``, remove the entire project directory, by default ``False``
+        """
+        if remove_root:
+            shutil.rmtree(self.source_path, ignore_errors=False)
+            return None
+
+        # Del files
+        for file in self._files.values():
+            if file.path.exists():
+                file.path.unlink()
+
+        # Del folders
+        for x in self._folders.values():
+            shutil.rmtree(x.absolute(), ignore_errors=False)
+
+    # Template loader
+    # -----------------------------------------
+    @classmethod
+    def from_template_dict(
+        cls,
+        source_path: str | Path,
+        template: ProjectDirInitTemplate,
+        *,
+        variables: Mapping[str, str] | None = None,
+        create_if_not_exist: bool = True,
+        auto_generate: bool = True,
+    ) -> Self:
+        """
+        Create a project from a dictionary template.
+
+        Parameters
+        ----------
+        source_path : str | Path
+            Root project directory.
+
+        template : Mapping[str, Any]
+            Template definition.
+
+        variables : Mapping[str, str], optional
+            Variables used for string formatting.
+
+        create_if_not_exist : bool, optional
+            Create project root if missing, by default ``True``
+
+        auto_generate : bool, optional
+            Generate files/folders immediately, by default ``True``
+
+        Returns
+        -------
+        Self
+            Project with loaded template
+        """
+        project = cls(
+            source_path,
+            create_if_not_exist=create_if_not_exist,
+            auto_generate=auto_generate,
+        )
+
+        vars_ = variables or {}
+
+        # Folders
+        for folder in template.get("folders", []):
+            project.add_folder(folder.format(**vars_))
+
+        # Files
+        for path, content in template.get("files", {}).items():
+            project.add_file(
+                path.format(**vars_),
+                content=(content or "").format(**vars_),
+            )
+
+        return project
+
+    @classmethod
+    def from_template_json(
+        cls,
+        source_path: str | Path,
+        json_path: str | Path,
+        *,
+        variables: Mapping[str, str] | None = None,
+        create_if_not_exist: bool = True,
+        auto_generate: bool = True,
+        encoding: str = "utf-8",
+    ) -> Self:
+        """
+        Create a project from a JSON template file.
+
+        Parameters
+        ----------
+        source_path : str | Path
+            Root project directory.
+
+        json_path : str | Path
+            Path to .json template.
+
+        variables : Mapping[str, str], optional
+            Variables used for string formatting.
+
+        create_if_not_exist : bool, optional
+            Create project root if missing, by default ``True``
+
+        auto_generate : bool, optional
+            Generate files/folders immediately, by default ``True``
+
+        encoding : str
+            .json encoding
+
+        Returns
+        -------
+        Self
+            Project with loaded template
+        """
+        json_path = Path(json_path)
+
+        with json_path.open(encoding=encoding) as f:
+            template = json.load(f)
+
+        return cls.from_template_dict(
+            source_path,
+            template,
+            variables=variables,
+            create_if_not_exist=create_if_not_exist,
+            auto_generate=auto_generate,
+        )
+
+
 # Class - SaveFileAs
 # ---------------------------------------------------------------------------
 class SaveFileAs:
-    """File as multiple file type"""
+    """
+    File as multiple file type
+    """
 
     def __init__(self, data: Any, *, encoding: str | None = "utf-8") -> None:
         """
@@ -552,9 +1178,3 @@ class SaveFileAs:
     #     from absfuyu.util.json_method import JsonFile
     #     temp = JsonFile(path, sort_keys=False)
     #     temp.save_json()
-
-
-# Dev and Test new feature before get added to the main class
-# ---------------------------------------------------------------------------
-class _NewDirFeature(Directory):
-    pass