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

absfuyu/sort.py

@@ -3,8 +3,8 @@ Absfuyu: Sort
 -------------
 Sort Module
 
-Version: 1.3.0
-Date updated: 11/02/2025 (mm/dd/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
 
 # Module level
@@ -26,7 +26,7 @@ from typing import Any
 
 # Functions
 # ---------------------------------------------------------------------------
-def selection_sort(iterable: list, reverse: bool = False) -> list:
+def selection_sort[T](iterable: list[T], reverse: bool = False) -> list[T]:
     """
     Sort the list with selection sort (bubble sort) algorithm
 
@@ -61,7 +61,7 @@ def selection_sort(iterable: list, reverse: bool = False) -> list:
         return iterable
 
 
-def insertion_sort(iterable: list) -> list:
+def insertion_sort[T](iterable: list[T]) -> list[T]:
     """
     Sort the list with insertion sort algorithm
 

absfuyu/tools/__init__.py

@@ -3,6 +3,32 @@ Absfuyu: Tools
 --------------
 Some useful tools
 
-Version: 5.0.0
-Date updated: 15/02/2025 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
+
+# Module Package
+# ---------------------------------------------------------------------------
+__all__ = [
+    #     # Main
+    "Checksum",
+    "B64",
+    "T2C",
+    #     "Charset",
+    #     "Generator",
+    "Inspector",
+    "inspect_all",
+    #     "Obfuscator",
+    #     "StrShifter",
+]
+
+
+# Library
+# ---------------------------------------------------------------------------
+from absfuyu.tools.checksum import Checksum
+from absfuyu.tools.converter import Base64EncodeDecode as B64
+from absfuyu.tools.converter import Text2Chemistry as T2C
+from absfuyu.tools.inspector import Inspector, inspect_all
+
+# from absfuyu.tools.generator import Charset, Generator  # circular import bug
+# from absfuyu.tools.obfuscator import Obfuscator, StrShifter  # circular import bug

absfuyu/tools/checksum.py

@@ -3,13 +3,19 @@ Absufyu: Checksum
 -----------------
 Check MD5, SHA256, ...
 
-Version: 5.0.0
-Date updated: 13/02/2025 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
 
 # Module level
 # ---------------------------------------------------------------------------
-__all__ = ["Checksum", "ChecksumMode"]
+__all__ = [
+    # Checksum
+    "Checksum",
+    "ChecksumMode",
+    # Mixin
+    "DirectoryRemoveDuplicateMixin",
+]
 
 
 # Library
@@ -19,7 +25,11 @@ from enum import StrEnum
 from pathlib import Path
 from typing import Literal
 
-from absfuyu.core import BaseClass, deprecated, tqdm, versionadded, versionchanged
+from absfuyu.core.baseclass import BaseClass
+from absfuyu.core.docstring import deprecated, versionadded, versionchanged
+from absfuyu.core.dummy_func import tqdm
+from absfuyu.dxt import DictExt, ListExt
+from absfuyu.util.path import DirectoryBase
 
 
 # Function
@@ -62,9 +72,70 @@ class ChecksumMode(StrEnum):
     SHA512 = "sha512"
 
 
+class DuplicateSummary(DictExt[str, list[Path]]):
+    """
+    Duplicate file summary
+    """
+
+    def summary(self) -> int:
+        """
+        Show how many duplicates (include the original)
+
+        Returns
+        -------
+        int
+            How many duplicates
+        """
+        temp = self.__class__(self.copy())
+        try:
+            return sum(temp.apply(lambda x: len(x)).values())
+        except Exception as err:
+            print(f"Something wrong - {err}")
+
+    def remove_duplicates(self, dry_run: bool = True, keep_first: bool = True, debug: bool = False) -> None:
+        """
+        Remove duplicates
+
+        Parameters
+        ----------
+        dry_run : bool, optional
+            Simulate only (no files deleted), by default ``True``
+
+        keep_first : bool, optional
+            Keep the first duplicate file, will keep the last duplicate file when ``False``, by default ``True``
+        """
+        temp = self.__class__(self.copy())
+        removable_files = ListExt([x[1:] if keep_first else x[:-1] for x in temp.values()]).flatten()
+
+        for x in removable_files:
+            x: Path = x
+
+            if debug or dry_run:
+                print(f"Deleting {x}")
+            if dry_run:
+                continue
+
+            x.unlink(missing_ok=True)
+
+
 @versionchanged("4.1.1", reason="Checksum for entire folder is possible")
 @versionadded("4.1.0")
 class Checksum(BaseClass):
+    """
+    Checksum engine
+
+    Parameters
+    ----------
+    path : str | Path
+        Path to file/directory to perform checksum
+
+    hash_mode : ChecksumMode | Literal["md5", "sha1", "sha256", "sha512"], optional
+        Hash mode, by default ``"sha256"``
+
+    save_result_to_file : bool, optional
+        Save checksum result(s) to file, by default ``False``
+    """
+
     def __init__(
         self,
         path: str | Path,
@@ -73,7 +144,8 @@ class Checksum(BaseClass):
         ) = ChecksumMode.SHA256,
         save_result_to_file: bool = False,
     ) -> None:
-        """Checksum engine
+        """
+        Checksum engine
 
         Parameters
         ----------
@@ -84,7 +156,7 @@ class Checksum(BaseClass):
             Hash mode, by default ``"sha256"``
 
         save_result_to_file : bool, optional
-            Save checksum result(s) to file, by default False
+            Save checksum result(s) to file, by default ``False``
         """
         self.path = Path(path)
         self.hash_mode = hash_mode
@@ -112,7 +184,8 @@ class Checksum(BaseClass):
         """This performs checksum"""
 
         hash_engine = self._get_hash_engine().copy()
-        with open(Path(file), "rb") as f:
+        # with open(Path(file), "rb") as f:
+        with file.open("rb") as f:
             # Read and hash the file in 4K chunks. Reading the whole
             # file at once might consume a lot of memory if it is
             # large.
@@ -125,12 +198,14 @@ class Checksum(BaseClass):
         return hash_engine.hexdigest()  # type: ignore
 
     def checksum(self, recursive: bool = True) -> str:
-        """Perform checksum
+        """
+        Perform checksum
 
         Parameters
         ----------
         recursive : bool, optional
-            Do checksum for every file in the folder (including child folder), by default True
+            Do checksum for every file in the folder (including child folder),
+            by default ``True``
 
         Returns
         -------
@@ -163,3 +238,63 @@ class Checksum(BaseClass):
                 f.write(output)
 
         return output
+
+
+# Mixin
+class DirectoryRemoveDuplicateMixin(DirectoryBase):
+    """
+    Directory - Remove duplicate by SHA256
+
+    - remove_duplicate
+    """
+
+    def __init__(self, source_path, create_if_not_exist=False) -> None:
+        super().__init__(source_path, create_if_not_exist)
+
+        self._duplicate_cache: DuplicateSummary | None = None
+
+    def _gather_duplicate_cache(self, recursive: bool = True) -> None:
+        engine = Checksum(self.source_path, hash_mode=ChecksumMode.SHA256, save_result_to_file=False)
+        valid = [x for x in engine.path.glob("**/*" if recursive else "*") if x.is_file()]
+        checksum_cache = {}
+
+        # Checksum
+        for x in tqdm(valid, unit_scale=True, desc="Checking..."):
+            try:
+                cs_res = engine._checksum_operation(x)
+
+                if checksum_cache.get(cs_res) is None:
+                    checksum_cache[cs_res] = [x]
+                else:
+                    checksum_cache[cs_res] += [x]
+            except Exception as err:
+                print(f"ERROR: {x} - {err}")
+                continue
+
+        # Save to cache
+        self._duplicate_cache = DuplicateSummary({k: v for k, v in checksum_cache.items() if len(v) > 1})
+
+    def remove_duplicate(self, dry_run: bool = True, recursive: bool = True, debug: bool = True) -> None:
+        """
+        Remove duplicate files by SHA256 checksum
+
+        Parameters
+        ----------
+        dry_run : bool, optional
+            Simulate only (no files deleted), by default ``True``
+
+        recursive : bool, optional
+            Scan every file in the folder (including child folder), by default ``True``
+
+        debug : bool, optional
+            Print delete messages, by default ``True``
+        """
+        self._gather_duplicate_cache(recursive=recursive)
+
+        # Remove
+        try:
+            summary = self._duplicate_cache
+            print(f"Duplicate files: {summary.summary()}")
+            summary.remove_duplicates(dry_run=dry_run, keep_first=False, debug=debug)
+        except Exception as err:
+            pass

absfuyu/tools/converter.py

@@ -3,8 +3,8 @@ Absufyu: Converter
 ------------------
 Convert stuff
 
-Version: 5.0.0
-Date updated: 11/02/2025 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 
 Feature:
 --------
@@ -16,9 +16,11 @@ Feature:
 # Module level
 # ---------------------------------------------------------------------------
 __all__ = [
+    "Base64EncodeDecode",
     "Text2Chemistry",
     "Str2Pixel",
-    "Base64EncodeDecode",
+    # Support
+    "ChemistryElement",
 ]
 
 
@@ -32,10 +34,11 @@ from itertools import chain, combinations
 from pathlib import Path
 from typing import Self
 
-from absfuyu.core import BaseClass, CLITextColor, versionadded
+from absfuyu.core.baseclass import BaseClass, CLITextColor
+from absfuyu.core.docstring import versionadded
 from absfuyu.logger import logger
 from absfuyu.pkg_data import DataList, DataLoader
-from absfuyu.util import set_min
+from absfuyu.util.text_table import OneColumnTableMaker
 
 
 # Class
@@ -84,14 +87,43 @@ class Base64EncodeDecode(BaseClass):
 
 
 class ChemistryElement(BaseClass):
-    """Chemistry Element"""
+    """
+    Chemistry Element
+
+    Parameters
+    ----------
+    name : str
+        Element name
+
+    number : int
+        Order in periodic table
+
+    symbol : str
+        Short symbol of element
+
+    atomic_mass : float
+        Atomic mass of element
+    """
+
+    __slots__ = ("name", "number", "symbol", "atomic_mass")
 
     def __init__(self, name: str, number: int, symbol: str, atomic_mass: float) -> None:
         """
-        name: element name
-        number: order in periodic table
-        symbol: short symbol of element
-        atomic_mass: atomic mass of element
+        Chemistry Element
+
+        Parameters
+        ----------
+        name : str
+            Element name
+
+        number : int
+            Order in periodic table
+
+        symbol : str
+            Short symbol of element
+
+        atomic_mass : float
+            Atomic mass of element
         """
         self.name = name
         self.number = number
@@ -105,23 +137,28 @@ class ChemistryElement(BaseClass):
         """
         Output content to dict
 
-        :rtype: dict[str, str | int | float]
+        Returns
+        -------
+        dict[str, str | int | float]
+            Dict version of element
         """
-        return {
-            "name": self.name,
-            "number": self.number,
-            "symbol": self.symbol,
-            "atomic_mass": self.atomic_mass,
-        }
+        # return {"name": self.name, "number": self.number, "symbol": self.symbol, "atomic_mass": self.atomic_mass}
+        return {x: getattr(self, x) for x in self.__slots__}
 
     @classmethod
     def from_dict(cls, data: dict[str, str | int | float]) -> Self:
         """
         Convert from ``dict`` data
 
-        :param data: Dict data
-        :type data: dict[str, str | int | float]
-        :rtype: ChemistryElement
+        Parameters
+        ----------
+        data : dict[str, str | int | float]
+            Dict data
+
+        Returns
+        -------
+        Self
+            ChemistryElement
         """
         return cls(
             name=data["name"],  # type: ignore
@@ -132,6 +169,10 @@ class ChemistryElement(BaseClass):
 
 
 class Text2Chemistry(BaseClass):
+    """
+    Convert text into chemistry symbols.
+    """
+
     def __init__(self) -> None:
         self.data_location = DataList.CHEMISTRY
 
@@ -150,7 +191,10 @@ class Text2Chemistry(BaseClass):
         """
         Characters that can not be converted (unvailable chemistry symbol)
 
-        :rtype: set[str]
+        Returns
+        -------
+        set[str]
+            Set of unvailable characters
         """
         base = set(string.ascii_lowercase)
         available = set(
@@ -164,10 +208,20 @@ class Text2Chemistry(BaseClass):
         """
         Convert text to chemistry symbol
 
-        :param text: desired text
-        :type text: str
-        :returns: Converted text (empty list when failed to convert)
-        :rtype: list
+        Parameters
+        ----------
+        text : str
+            Desired text
+
+        Returns
+        -------
+        list[list[ChemistryElement]] | list
+            Converted text (empty list when failed to convert)
+
+        Raises
+        ------
+        ValueError
+            When text contains digit, whitespaces, ...
         """
         # Check if `text` is a word (without digits)
         is_word_pattern = r"^[a-zA-Z]+$"
@@ -253,21 +307,50 @@ class Text2Chemistry(BaseClass):
         if len(result) == 0:
             res = "No possible combination"
         else:
-            msg = []
+            header = ["Text to Chemistry"]
+            body = []
+            max_table_len = len(header[0])
+
             for i, solution in enumerate(result, start=1):
+                msg = []
                 max_word_len = max([len(x.name) for x in solution])
                 msg.append(f"Option {i:02}: {', '.join([x.symbol for x in solution])}")
                 for x in solution:
                     msg.append(
-                        f"{x.symbol.ljust(2)} ({x.number:02}. {x.name.ljust(max_word_len)} - {round(x.atomic_mass, 2)})"
+                        f"{x.symbol.ljust(2)} "
+                        f"({x.number:02}. {x.name.ljust(max_word_len)}"
+                        f" - {round(x.atomic_mass, 2)})"
                     )
-                msg.append("---")
-            res = "\n".join(msg)
+                body.append(msg)
+
+            max_table_len = max(
+                max([max([len(x) for x in opt]) for opt in body]), max_table_len
+            )
+            table = OneColumnTableMaker(ncols=max_table_len + 4, style="normal")
+            table.add_paragraph(header)
+            for x in body:
+                table.add_paragraph(x)
+
+            res = table.make_table()
         return res
 
 
 class Str2Pixel(BaseClass):
-    """Convert str into pixel"""
+    """
+    Convert str into pixel
+
+    Parameters
+    ----------
+    str_data : str
+        | Pixel string data (Format: ``<number_of_pixel><color_code>``)
+        | Example: ``50w20b`` = 50 white pixels and 20 black pixels
+
+    pixel_size : int, optional
+        Pixel size, by default ``2``
+
+    pixel_symbol_overwrite : str | None, optional
+        Overwrite pixel symbol, by default ``None``
+    """
 
     PIXEL = "\u2588"
 
@@ -279,11 +362,13 @@ class Str2Pixel(BaseClass):
         pixel_symbol_overwrite: str | None = None,
     ) -> None:
         """
+        Convert str into pixel
+
         Parameters
         ----------
         str_data : str
-            Pixel string data (Format: ``<number_of_pixel><color_code>``)
-            Example: 50w20b = 50 white pixels and 20 black pixels
+            | Pixel string data (Format: ``<number_of_pixel><color_code>``)
+            | Example: ``50w20b`` = 50 white pixels and 20 black pixels
 
         pixel_size : int, optional
             Pixel size, by default ``2``
@@ -293,7 +378,7 @@ class Str2Pixel(BaseClass):
         """
         self.data = str_data
         if pixel_symbol_overwrite is None:
-            self.pixel = self.PIXEL * int(set_min(pixel_size, min_value=1))
+            self.pixel = self.PIXEL * int(max(pixel_size, 1))
         else:
             self.pixel = pixel_symbol_overwrite
 
@@ -307,7 +392,8 @@ class Str2Pixel(BaseClass):
         return [x for y in zip(num, char) for x in y]
 
     def convert(self, line_break: bool = True) -> str:
-        """Convert data into pixel
+        """
+        Convert data into pixel
 
         Parameters
         ----------