absfuyu 3.2.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

absfuyu/util/path.py

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
 Absfuyu: Path
 -------------
 Path related
 
-Version: 1.5.1
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 1.6.5
+Date updated: 10/04/2024 (dd/mm/yyyy)
 
 Feature:
 --------
@@ -13,138 +12,152 @@ Feature:
 - SaveFileAs
 """
 
-
 # Module level
 ###########################################################################
 __all__ = [
-    # "here_location", "location_wrap", "get_all_file_path",
+    # Main
     "Directory",
-    "SaveFileAs"
+    "SaveFileAs",
+    # Support
+    "FileOrFolderWithModificationTime",
+    "DirectoryInfo",
 ]
 
 
 # Library
 ###########################################################################
-from datetime import datetime
-from functools import partial
 import os
-from pathlib import Path
 import re
 import shutil
-from typing import Any, List, Literal, Tuple, Union
+from datetime import datetime
+from functools import partial
+from pathlib import Path
+from typing import Any, List, Literal, NamedTuple, Optional, Union
+
+from deprecated.sphinx import versionadded
 
-from absfuyu.logger import logger
+from absfuyu.logger import LogLevel, logger
 
 
-# Function
+# Support Class
 ###########################################################################
-def here_location(): # Depreciated
+@versionadded(version="3.3.0")
+class FileOrFolderWithModificationTime(NamedTuple):
     """
-    Return current file location
-    
-    If fail then return current working directory
-    """
-    try:
-        return os.path.abspath(os.path.dirname(__file__))
-    except:
-        return os.getcwd()
-    
-    # return os.path.abspath(os.path.dirname(__file__))
-
-def location_wrap(file_location: str): # Depreciated
-    """
-    This function fix some `current working directory` error and return `abspath`
-    """
-    assert isinstance(file_location, str), "Must be a string"
-    try: 
-        here = here_location()
-    except:
-        here = ""
-    return os.path.join(here, file_location)
-
-def get_all_file_path(folder: str, *file_type: str) -> list: # Depreciated
-    """
-    Return a list of tuple: (path to choosen file type, filename)
-    
-    - ``folder``: Folder path to search in
-    - ``file_type``: File type/extension without the ``"."`` symbol. 
-    
-    Support multiple file type (separate with ``","`` (coma)) 
-    (Example: ``jpg``, ``png``, ``npy``)
+    File or Folder with modification time
+
+    :param path: Original path
+    :param modification_time: Modification time
     """
-    # Check file type
-    # If no `file_type` entered then proceed to print available file type
-    if len(file_type) < 1:
-        available_file_type = []
-        for _, _, files in os.walk(folder):
-            for file in files:
-                temp = re.search(r"\b.*[.](\w+$)\b", file)
-                if temp is not None:
-                    available_file_type.append(temp[1])
-        # print(f"Available file type: {set(available_file_type)}")
-        # return list(set(available_file_type))
-        # return None
-        raise ValueError(f"Available file type: {set(available_file_type)}")
-
-    # Generate regex pattern
-    temp_pattern = "|".join(f"[.]{x}" for x in file_type)
-    pattern = f"\\b^([\w ]+)({temp_pattern}$)\\b"
-    # print("Search pattern: ", pattern)
-    
-    # Iter through each folder to find file
-    file_location = []
-    # for root, dirs, files in os.walk(folder):
-    for root, _, files in os.walk(folder):
-        for file in files:
-            result = re.search(pattern, file)
-            if result is not None:
-                file_location.append((os.path.join(root, file), result[1]))
-    return file_location
-
-def here_sniplet():
-    """Return current file location code"""
-    snip = """\
-import os
-here = os.path.abspath(os.path.dirname(__file__))
 
-from pathlib import Path
-here = Path(__file__)
-"""
-    return snip
+    path: Path
+    modification_time: datetime
+
+
+@versionadded(version="3.3.0")
+class DirectoryInfo(NamedTuple):
+    """Information of a directory"""
+
+    files: int
+    folders: int
+    creation_time: datetime
+    modification_time: datetime
 
 
-# Class
+# Class - Directory | version 3.4.0: Remake Directory into modular class
 ###########################################################################
-class Directory:
-    """
-    Some shortcuts for directory
-    
-    - list_structure
-    - delete, rename, copy, move
-    - zip
-    """
+class DirectoryBase:
     def __init__(
-            self,
-            source_path: Union[str, Path],
-            create_if_not_exist: bool = False,
-        ) -> None:
+        self,
+        source_path: Union[str, Path],
+        create_if_not_exist: bool = False,
+    ) -> None:
         """
-        source_path: Source folder
-        create_if_not_exist: Create directory when not exist
+        Parameters
+        ----------
+        source_path : str | Path
+            Source folder
+
+        create_if_not_exist : bool
+            Create directory when not exist
+            (Default: ``False``)
         """
-        self.source_path = Path(source_path).absolute()
+        self.source_path = Path(source_path)
         if create_if_not_exist:
-            self.source_path.mkdir(exist_ok=True)
+            if not self.source_path.exists():
+                self.source_path.mkdir(exist_ok=True, parents=True)
+
     def __str__(self) -> str:
-        return f"{self.__class__.__name__}({self.source_path})"
+        return self.source_path.__str__()
+
     def __repr__(self) -> str:
-        return 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(version="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(version="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())
+
+    @versionadded(version="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 information
+    @versionadded(version="3.3.0")
+    def quick_info(self) -> DirectoryInfo:
+        """
+        Quick information about this Directory
+
+        :rtype: 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):
     # Rename
     def rename(self, new_name: str) -> None:
         """
         Rename directory
-        
+
         Parameters
         ----------
         new_name : str
@@ -152,13 +165,12 @@ class Directory:
         """
         try:
             logger.debug(f"Renaming to {new_name}...")
-            self.source_path.rename(
-                self.source_path.parent.joinpath(new_name)
-            )
+            self.source_path.rename(self.source_path.with_name(new_name))
             logger.debug(f"Renaming to {new_name}...DONE")
         except Exception as e:
             logger.error(e)
-    
+        # return self.source_path
+
     # Copy
     def copy(self, dst: Path) -> None:
         """
@@ -173,14 +185,14 @@ class Directory:
         try:
             try:
                 shutil.copytree(self.source_path, Path(dst), dirs_exist_ok=True)
-            except:
+            except Exception:
                 shutil.copytree(self.source_path, Path(dst))
             logger.debug(f"Copying to {dst}...DONE")
         except Exception as e:
             logger.error(e)
-    
+
     # Move
-    def move(self, dst: Path) -> None:
+    def move(self, dst: Path, content_only: bool = False) -> None:
         """
         Move entire directory
 
@@ -188,99 +200,40 @@ class Directory:
         ----------
         dst : Path
             Destination
+
+        content_only : bool
+            Only move content inside the folder (Default: ``False``; Move entire folder)
         """
         try:
             logger.debug(f"Moving to {dst}...")
-            shutil.move(self.source_path, Path(dst))
+            if content_only:
+                for x in self.source_path.iterdir():
+                    shutil.move(x, Path(dst))
+            else:
+                shutil.move(self.source_path, Path(dst))
             logger.debug(f"Moving to {dst}...DONE")
-        except Exception as e:
-            logger.error(e)
-
-    # Directory structure
-    def _list_dir(self, *ignore: str) -> List[Path]:
-        """List all directories and files"""
-        logger.debug(f"Base folder: {self.source_path.name}")
-
-        temp = self.source_path.glob("**/*")
-        # No ignore rules
-        if len(ignore) == 0:
-            return [x.relative_to(self.source_path) for x in temp]
 
-        # With ignore rules
-        ignore_pattern = "|".join(ignore)
-        logger.debug(f"Ignore pattern: {ignore_pattern}")
-        return [x.relative_to(self.source_path) for x in temp if re.search(ignore_pattern, x.name) is None]
+        except shutil.Error as e:  # File already exists
+            logger.error(e)
+            logger.debug("Overwriting file...")
+            if content_only:
+                for x in self.source_path.iterdir():
+                    shutil.move(x, Path(dst).joinpath(x.name))
+            else:
+                shutil.move(self.source_path, Path(dst))
+            logger.debug("Overwriting file...DONE")
 
-    def _separate_dir_and_files(
-            self,
-            list_of_paths: List[Path],
-            *,
-            tab_symbol: str = None,
-            sub_dir_symbol: str = None
-        ) -> List[str]:
+    # Delete folder
+    def _mtime_folder(self) -> List[FileOrFolderWithModificationTime]:
         """
-        Separate dir and file and transform into folder structure
-        
-        list_of_paths: List of paths
-        tab_symbol: Tab symbol
-        sub_dir_symbol: Sub-directory symbol
+        Get modification time of file/folder (first level only)
         """
-        if not tab_symbol:
-            tab_symbol = "\t"
-        if not sub_dir_symbol:
-            sub_dir_symbol = "|-- "
-
-        temp = sorted([str(x).split("/") for x in list_of_paths]) # Linux
-        if max(map(len, temp)) == 1:
-            temp = sorted([str(x).split("\\") for x in list_of_paths]) # Windows
-
-        return [f"{tab_symbol*(len(x)-1)}{sub_dir_symbol}{x[-1]}" for x in temp]
-
-    def list_structure(self, *ignore: str) -> str:
-        """
-        List folder structure
-
-        Parameters
-        ----------
-        ignore : str
-            Tuple contains patterns to ignore
-        
-        Returns
-        -------
-        str
-            Directory structure
-
-
-        Example (For typical python library):
-        -------------------------------------
-        >>> test = Directory(<source path>)
-        >>> test.list_structure(
-                "__pycache__",
-                ".pyc",
-                "__init__", 
-                "__main__",
+        return [
+            FileOrFolderWithModificationTime(
+                path, datetime.fromtimestamp(path.stat().st_mtime)
             )
-        ...
-        """
-        temp = self._list_dir(*ignore)
-        out = self._separate_dir_and_files(temp)
-        return "\n".join(out)
-    
-    def list_structure_pkg(self) -> str:
-        """
-        List folder structure of a typical python package
-        
-        Returns
-        -------
-        str
-            Directory structure
-        """
-        return self.list_structure("__pycache__", ".pyc")
-
-    # Delete folder
-    def _mtime_folder(self) -> List[Tuple[Path, datetime]]:
-        """Get modification time of file/folder"""
-        return [(x, datetime.fromtimestamp(x.stat().st_mtime)) for x in self.source_path.glob("*")]
+            for path in self.source_path.glob("*")
+        ]
 
     @staticmethod
     def _delete_files(list_of_files: List[Path]) -> None:
@@ -295,39 +248,34 @@ class Directory:
                     shutil.rmtree(x)
                 else:
                     x.unlink()
-                logger.debug(f"Removing {x}...REMOVED")
-            except:
+                logger.debug(f"Removing {x}...SUCCEED")
+            except Exception:
                 logger.error(f"Removing {x}...FAILED")
 
     @staticmethod
     def _date_filter(
-            value: Tuple[Path, datetime], 
-            period: Literal["Y", "M", "D"] = "Y"
-        ) -> bool:
+        value: FileOrFolderWithModificationTime,
+        period: Literal["Y", "M", "D"] = "Y",
+    ) -> bool:
         """
         Filter out file with current Year|Month|Day
         """
-        period = period.upper().strip()
         data = {
-            "Y": value[1].year, 
-            "M": value[1].month, 
-            "D": value[1].day
+            "Y": value.modification_time.year,
+            "M": value.modification_time.month,
+            "D": value.modification_time.day,
         }
         now = datetime.now()
-        ntime = {
-            "Y": now.year, 
-            "M": now.month, 
-            "D": now.day
-        }
+        ntime = {"Y": now.year, "M": now.month, "D": now.day}
         return data[period] != ntime[period]
 
     def delete(
-            self, 
-            entire: bool = False,
-            *,
-            based_on_time: bool = False,
-            keep: Literal["Y", "M", "D"] = "Y"
-        ) -> None:
+        self,
+        entire: bool = False,
+        *,
+        based_on_time: bool = False,
+        keep: Literal["Y", "M", "D"] = "Y",
+    ) -> None:
         """
         Deletes everything
 
@@ -337,36 +285,41 @@ class Directory:
             | ``True``: Deletes the folder itself
             | ``False``: Deletes content inside only
             | (Default: ``False``)
-        
+
         based_on_time : bool
             | ``True``: Deletes everything except ``keep`` period
             | ``False``: Works normal
             | (Default: ``False``)
-        
+
         keep : Literal["Y", "M", "D"]
             Delete all file except current ``Year`` | ``Month`` | ``Day``
         """
         try:
             logger.info(f"Removing {self.source_path}...")
-            
+
             if entire:
                 shutil.rmtree(self.source_path)
             else:
                 if based_on_time:
                     filter_func = partial(self._date_filter, period=keep)
-                    self._delete_files([x[0] for x in filter(filter_func, self._mtime_folder())])
+                    # self._delete_files([x[0] for x in filter(filter_func, self._mtime_folder())])
+                    self._delete_files(
+                        [x.path for x in filter(filter_func, self._mtime_folder())]
+                    )
                 else:
-                    self._delete_files(map(lambda x: x[0], self._mtime_folder()))
-            
-            logger.info(f"Removing {self.source_path}...COMPLETED")
-        except:
-            logger.error(f"Removing {self.source_path}...FAILED")
+                    self._delete_files(
+                        map(lambda x: x.path, self._mtime_folder())  # type: ignore
+                    )
+
+            logger.info(f"Removing {self.source_path}...SUCCEED")
+        except Exception as e:
+            logger.error(f"Removing {self.source_path}...FAILED\n{e}")
 
     # Zip
-    def compress(self, *, format: str = "zip") -> None:
+    def compress(self, *, format: str = "zip") -> Union[Path, None]:
         """
         Compress the directory (Default: Create ``.zip`` file)
-        
+
         Parameters
         ----------
         format : Literal["zip", "tar", "gztar", "bztar", "xztar"]
@@ -375,38 +328,201 @@ class Directory:
             - ``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).
+
+        Returns
+        -------
+        Path
+            Compressed path
+        None
+            When fail to compress
         """
         logger.debug(f"Zipping {self.source_path}...")
         try:
-            zip_name = self.source_path.parent.joinpath(self.source_path.name)
-            shutil.make_archive(zip_name, format=format, root_dir=self.source_path)
+            # 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(
+                self.source_path.__str__(), format=format, root_dir=self.source_path
+            )
             logger.debug(f"Zipping {self.source_path}...DONE")
-        except:
-            logger.error(f"Zipping {self.source_path}...FAILED")
+            logger.debug(f"Path: {zip_path}")
+            return Path(zip_path)
+        except Exception as e:
+            logger.error(f"Zipping {self.source_path}...FAILED\n{e}")
+            return None
+
+
+class DirectoryTree(DirectoryBase):
+    pass
+
+
+class Directory(DirectoryBasicOperation, DirectoryTree):
+    """
+    Some shortcuts for directory
+
+    - list_structure
+    - delete, rename, copy, move
+    - zip
+    - quick_info
+    """
+
+    # Directory structure
+    def _list_dir(self, *ignore: str) -> List[Path]:
+        """
+        List all directories and files
+
+        Parameters
+        ----------
+        ignore : str
+            List of pattern to ignore. Example: "__pycache__", ".pyc"
+        """
+        logger.debug(f"Base folder: {self.source_path.name}")
 
+        list_of_path = self.source_path.glob("**/*")
 
+        # No ignore rules
+        if len(ignore) == 0:  # No ignore pattern
+            return [path.relative_to(self.source_path) for path in list_of_path]
+
+        # With ignore rules
+        # ignore_pattern = "|".join(ignore)
+        ignore_pattern = re.compile("|".join(ignore))
+        logger.debug(f"Ignore pattern: {ignore_pattern}")
+        return [
+            path.relative_to(self.source_path)
+            for path in list_of_path
+            if re.search(ignore_pattern, path.name) is None
+        ]
+
+    @staticmethod
+    @versionadded(version="3.3.0")
+    def _split_dir(list_of_path: List[Path]) -> List[List[str]]:
+        """
+        Split pathname by ``os.sep``
+
+        Parameters
+        ----------
+        list_of_path : list[Path]
+            List of Path
+
+        Returns
+        -------
+        list[list[str]]
+            List of splitted dir
+
+
+        Example:
+        --------
+        >>> test = [Path(test_root/test_not_root), ...]
+        >>> Directory._split_dir(test)
+        [[test_root, test_not_root], [...]...]
+        """
+
+        return sorted([str(path).split(os.sep) for path in list_of_path])
+
+    def _separate_dir_and_files(
+        self,
+        list_of_path: List[Path],
+        *,
+        tab_symbol: Optional[str] = None,
+        sub_dir_symbol: Optional[str] = None,
+    ) -> List[str]:
+        """
+        Separate dir and file and transform into folder structure
+
+        Parameters
+        ----------
+        list_of_path : list[Path]
+            List of paths
+
+        tab_symbol : str | None
+            Tab symbol
+            (Default: ``"\\t"``)
+
+        sub_dir_symbol : str | None
+            Sub-directory symbol
+            (Default: ``"|-- "``)
+
+        Returns
+        -------
+        list[str]
+            Folder structure ready to print
+        """
+        # Check for tab and sub-dir symbol
+        if not tab_symbol:
+            tab_symbol = "\t"
+        if not sub_dir_symbol:
+            sub_dir_symbol = "|-- "
+
+        temp: List[List[str]] = self._split_dir(list_of_path)
+
+        return [  # Returns n-tab space with sub-dir-symbol for the last item in x
+            f"{tab_symbol * (len(x) - 1)}{sub_dir_symbol}{x[-1]}" for x in temp
+        ]
+
+    def list_structure(self, *ignore: str) -> str:
+        """
+        List folder structure
+
+        Parameters
+        ----------
+        ignore : str
+            Tuple contains patterns to ignore
+
+        Returns
+        -------
+        str
+            Directory structure
+
+
+        Example (For typical python library):
+        -------------------------------------
+        >>> test = Directory(<source path>)
+        >>> test.list_structure(
+                "__pycache__",
+                ".pyc",
+                "__init__",
+                "__main__",
+            )
+        ...
+        """
+        temp: List[Path] = self._list_dir(*ignore)
+        out: List[str] = self._separate_dir_and_files(temp)
+        return "\n".join(out)  # Join the list
+
+    def list_structure_pkg(self) -> str:
+        """
+        List folder structure of a typical python package
+
+        Returns
+        -------
+        str
+            Directory structure
+        """
+        return self.list_structure("__pycache__", ".pyc")
+
+
+# Class - SaveFileAs
+###########################################################################
 class SaveFileAs:
     """File as multiple file type"""
-    def __init__(
-            self,
-            data: Any,
-            *,
-            encoding: Union[str, None] = "utf-8"
-        ) -> None:
+
+    def __init__(self, data: Any, *, encoding: Union[str, None] = "utf-8") -> None:
         """
         :param encoding: Default: utf-8
         """
         self.data = data
         self.encoding = encoding
+
     def __str__(self) -> str:
         return f"{self.__class__.__name__}()"
+
     def __repr__(self) -> str:
         return self.__str__()
 
     def to_txt(self, path: Union[str, Path]) -> None:
         """
         Save as ``.txt`` file
-        
+
         Parameters
         ----------
         path : Path
@@ -414,11 +530,11 @@ class SaveFileAs:
         """
         with open(path, "w", encoding=self.encoding) as file:
             file.writelines(self.data)
-    
+
     # def to_pickle(self, path: Union[str, Path]) -> None:
     #     """
     #     Save as .pickle file
-        
+
     #     :param path: Save location
     #     """
     #     from absfuyu.util.pkl import Pickler
@@ -427,7 +543,7 @@ class SaveFileAs:
     # def to_json(self, path: Union[str, Path]) -> None:
     #     """
     #     Save as .json file
-        
+
     #     :param path: Save location
     #     """
     #     from absfuyu.util.json_method import JsonFile
@@ -435,8 +551,13 @@ class SaveFileAs:
     #     temp.save_json()
 
 
+# Dev and Test new feature before get added to the main class
+###########################################################################
+class _NewDirFeature(Directory):
+    pass
+
+
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    logger.setLevel(10)
-    
+    logger.setLevel(LogLevel.DEBUG)