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

absfuyu/extra/img/dup_check.py

@@ -0,0 +1,291 @@
+"""
+Absfuyu: Image duplicate checker
+--------------------------------
+Image duplicate checker
+
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["DirectoryRemoveDuplicateImageMixin"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import StrEnum
+from functools import partial, total_ordering
+from pathlib import Path
+from typing import Literal, NamedTuple
+
+from absfuyu.core.dummy_func import tqdm as tqdm_base
+from absfuyu.tools.checksum import DirectoryRemoveDuplicateMixin, DuplicateSummary
+
+try:
+    import imagehash
+    from PIL import Image
+except ImportError:
+    from subprocess import run
+
+    from absfuyu.config import ABSFUYU_CONFIG
+
+    if ABSFUYU_CONFIG._get_setting("auto-install-extra").value:  # type: ignore
+        cmd = "python -m pip install -U absfuyu[pic]".split()
+        run(cmd)
+    else:
+        raise SystemExit("This feature is in absfuyu[pic] package")  # noqa: B904
+
+# Setup
+# ---------------------------------------------------------------------------
+tqdm = partial(tqdm_base, unit_scale=True, dynamic_ncols=True)
+SupportedImageFormat = {".jpg", ".jpeg", ".png", ".webp", ".bmp"}
+
+
+# Class
+# ---------------------------------------------------------------------------
+class HashMode(StrEnum):
+    PERCEPTUAL_HASH = "phash"
+    AVERAGE_HASH = "ahash"
+    DIFFERENCE_HASH = "dhash"
+    WAVELET_HASH = "whash"
+
+
+class DuplicateImgPair(NamedTuple):
+    """
+    Duplicate image pair
+
+    Parameters
+    ----------
+    original : Path
+        Original image path
+
+    duplicate : Path
+        Duplicate image path
+
+    distant : int
+        Similarity between image (0 is exact)
+    """
+
+    original: Path
+    duplicate: Path
+    distant: int
+
+
+@total_ordering
+@dataclass
+class ImageInfo:
+    """
+    Quick image info
+
+    Parameters
+    ----------
+    path : Path
+        Image path
+
+    file_size : int
+        File size
+
+    dimension : tuple[int, int]
+        Dimension (width, height)
+    """
+
+    path: Path
+    file_size: int
+    dimension: tuple[int, int]
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, self.__class__):
+            raise NotImplementedError("Not implemented")
+        return self.dimension == other.dimension and self.file_size == other.file_size
+
+    def __lt__(self, other) -> bool:
+        if not isinstance(other, self.__class__):
+            raise NotImplementedError("Not implemented")
+
+        # prioritize dimension first, then size
+        if self.dimension != other.dimension:
+            return self.dimension < other.dimension
+        return self.file_size < other.file_size
+
+
+class DirectoryRemoveDuplicateImageMixin(DirectoryRemoveDuplicateMixin):
+    """
+    Directory - Remove duplicate image
+
+    - remove_duplicate_images
+
+
+    Example:
+    --------
+    >>> DirectoryRemoveDuplicateImageMixin(".").remove_duplicate_images()
+    """
+
+    def __init__(self, source_path, create_if_not_exist=False) -> None:
+        super().__init__(source_path, create_if_not_exist)
+
+        # Unused yet
+        self._duplicate_image_cache = None
+
+    # Hash
+    def _get_img_hash_mode(
+        self, hash_mode: HashMode = HashMode.PERCEPTUAL_HASH
+    ) -> Callable[[Image, int], imagehash.ImageHash]:
+        """
+        Get image hash mode
+
+        Parameters
+        ----------
+        hash_mode : HashMode, optional
+            Hash mode, by default ``HashMode.PERCEPTUAL_HASH``
+
+        Returns
+        -------
+        Callable[[Image, int], imagehash.ImageHash]
+            Hash function
+        """
+        if hash_mode == HashMode.AVERAGE_HASH:
+            return imagehash.average_hash
+        elif hash_mode == HashMode.DIFFERENCE_HASH:
+            return imagehash.dhash
+        elif hash_mode == HashMode.WAVELET_HASH:
+            return imagehash.whash
+        else:
+            return imagehash.phash
+
+    def _gather_duplicate_image_cache(
+        self, recursive: bool = True, threshold: int = 5, hash_mode: HashMode = HashMode.PERCEPTUAL_HASH
+    ) -> None:
+        """
+        Gather duplicate image cache
+
+        Parameters
+        ----------
+        recursive : bool, optional
+            Scan every file in the folder (including child folder), by default ``True``
+
+        threshold : int, optional
+            Maximum hamming distance between image hashes to consider them "similar", by default ``5``
+            - 0: Exact image
+            - [5,10]: Tolerant of light edits
+
+        hash_mode : HashMode, optional
+            Hash mode, by default ``HashMode.PERCEPTUAL_HASH``
+        """
+        valid = [
+            x
+            for x in self.source_path.glob("**/*" if recursive else "*")
+            if x.is_file() and x.suffix.lower() in SupportedImageFormat
+        ]
+        hash_cache: dict[imagehash.ImageHash, list[Path]] = {}
+        duplicates: list[DuplicateImgPair] = []
+
+        # Checksum
+        for x in tqdm(valid, desc="Hashing image..."):
+            try:
+                with Image.open(x) as img:
+                    hash_func = self._get_img_hash_mode(hash_mode=hash_mode)
+                    hash = hash_func(img)  # perceptual hash
+
+            except Exception as err:
+                print(f"ERROR: {x} - {err}")
+                continue
+
+            # Compare against all cached hashes
+            found = False
+            for existing_hash, paths in hash_cache.items():
+                distance = hash - existing_hash
+                if distance <= threshold:
+                    duplicates.append(DuplicateImgPair(paths[0], x, distance))
+                    if x not in paths:
+                        paths.append(x)
+                    found = True
+                    break
+
+            if not found:
+                hash_cache[hash] = [x]
+
+        # Save to cache
+        self._duplicate_cache = DuplicateSummary({k: v for k, v in hash_cache.items() if len(v) > 1})
+        self._duplicate_image_cache = duplicates
+
+    # Remove
+    def _gather_img_info(self, image_path: Path) -> ImageInfo:
+        with Image.open(image_path) as img:
+            dim = img.size
+        return ImageInfo(image_path, image_path.stat().st_size, dim)
+
+    def _remove_duplicate_image_best(self, dry_run: bool = True, debug: bool = True) -> None:
+        """This will take image with large size in dimension and storage"""
+        if self._duplicate_cache is None or self._duplicate_image_cache is None:
+            raise ValueError("No duplicates found")
+
+        del_list: list[ImageInfo] = []
+        for paths in self._duplicate_cache.values():
+            # Sort image by dimension then size ascending order then cut the last value
+            data = sorted([self._gather_img_info(img) for img in paths])[:-1]
+            # Extend to delete list
+            del_list.extend(data)
+
+        for i, x in enumerate(del_list, start=1):
+            if debug:
+                print(f"{i:02}. Deleting {x.path}")
+            if not dry_run:
+                x.path.unlink(missing_ok=True)
+
+    # Main
+    def remove_duplicate_images(
+        self,
+        dry_run: bool = True,
+        recursive: bool = True,
+        threshold: int = 5,
+        hash_mode: HashMode = HashMode.PERCEPTUAL_HASH,
+        keep_mode: Literal["first", "last", "best"] = "best",
+        debug: bool = True,
+    ) -> None:
+        """
+        Remove duplicate images in a directory
+
+        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``
+
+        threshold : int, optional
+            Maximum hamming distance between image hashes to consider them "similar", by default ``5``
+            - 0: Exact image
+            - [5,10]: Tolerant of light edits
+
+        hash_mode : HashMode, optional
+            Hash mode, by default ``HashMode.PERCEPTUAL_HASH``
+
+        keep_mode : Literal["first", "last", "best"], optional
+            What to keep in duplicate images, by default ``"best"``
+            - "first": First item in delete list
+            - "last": Last item in delete list
+            - "best": Best item (largest dimension and size) in delete list
+
+        debug : bool, optional
+            Debug message, by default ``True``
+        """
+        # Cache
+        self._gather_duplicate_image_cache(recursive=recursive, threshold=threshold, hash_mode=hash_mode)
+
+        # Remove
+        try:
+            if keep_mode in ["first", "last"]:
+                summary = self._duplicate_cache
+                print(f"Duplicate files: {summary.summary()}")
+                summary.remove_duplicates(dry_run=dry_run, keep_first=keep_mode == "first", debug=debug)
+
+            else:  # best mode
+                self._remove_duplicate_image_best(dry_run=dry_run, debug=debug)
+
+        except Exception as err:
+            pass

absfuyu/extra/pdf.py

@@ -3,8 +3,8 @@ Absfuyu: PDF
 ------------
 PDF Tool [W.I.P]
 
-Version: 5.6.1
-Date updated: 12/09/2025 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
 
 # Module level
@@ -31,18 +31,16 @@ except ImportError:
     from absfuyu.config import ABSFUYU_CONFIG
 
     if ABSFUYU_CONFIG._get_setting("auto-install-extra").value:  # type: ignore
-        cmd = "python -m pip install -U absfuyu[full]".split()
+        cmd = "python -m pip install -U absfuyu[pdf]".split()
         run(cmd)
     else:
-        raise SystemExit("This feature is in absfuyu[full] package")  # noqa: B904
+        raise SystemExit("This feature is in absfuyu[pdf] package")  # noqa: B904
 else:
     PDF_MODE = True
 
 
 # Class
 # ---------------------------------------------------------------------------
-
-
 class PDFTool(BaseClass):
     def __init__(self) -> None:
         super().__init__()

absfuyu/extra/rclone.py

@@ -0,0 +1,253 @@
+"""
+Absfuyu: Rclone decrypt
+-----------------------
+Rclone decryptor
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["RcloneEncryptDecrypt", "DirectoryRcloneDEMixin"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+import os
+import shutil
+from pathlib import Path
+from typing import Literal, Self
+
+from rclone import Crypt
+
+from absfuyu.core.baseclass import AutoREPRMixin
+from absfuyu.logger import LogLevel, logger
+from absfuyu.util.path import DirectoryBase
+
+
+# Class
+# ---------------------------------------------------------------------------
+class RcloneEncryptDecrypt(AutoREPRMixin):
+    """
+    Rclone Decrypt/Encrypt Module
+    """
+
+    def __init__(self, crypt: Crypt) -> None:
+        """
+        This will encrypt/decrypt with rclone style
+
+        Parameters
+        ----------
+        crypt : Crypt
+            ``rclone.Crypt`` object | Encrypt/Decrypt engine
+        """
+        self._crypt = crypt
+
+    @classmethod
+    def from_passwd_salt(cls, passwd: str, salt: str | None = None) -> Self:
+        """
+        Create Rclone Decrypt/Encrypt object from password and salt
+
+        Parameters
+        ----------
+        passwd : str
+            Custom password
+
+        salt : str | None, optional
+            Custom salt, by default None
+
+        Returns
+        -------
+        Self
+            Rclone Decrypt/Encrypt object
+        """
+        if salt is None:
+            crypt: Crypt = Crypt(passwd=passwd)
+        else:
+            crypt: Crypt = Crypt(passwd=passwd, salt=salt)
+        return cls(crypt)
+
+    # Support
+    @staticmethod
+    def _directory_validator(path: Path) -> Path:
+        """Validate if directory exists, then return the path"""
+        path = Path(path)
+        if not path.exists():
+            raise ValueError("Path does not exist")
+        return path
+
+    def _modify_name(self, name_to_modify: str, mode: Literal["encrypt", "decrypt"]) -> str:
+        if mode == "decrypt":
+            return self._crypt.Name.standard_decrypt(name_to_modify)
+        if mode == "encrypt":
+            return self._crypt.Name.standard_encrypt(name_to_modify)
+
+    def _decrypt_encrypt_operation(
+        self,
+        mode: Literal["encrypt", "decrypt"],
+        root_dir: Path | str,  # type: ignore
+        delete_when_complete: bool = False,
+    ) -> None:
+        """
+        Base operation to decrypt, encrypt
+
+        Parameters
+        ----------
+        mode : Literal["encrypt", "decrypt"]
+            Encrypt or decrypt
+
+        root_dir : Path | str
+            Directory location
+
+        delete_when_complete : bool
+            Delete directory when completed, defaults to False
+        """
+
+        logger.info(f"Begin operation: {mode.title()}")
+        root_dir = Path(root_dir)
+        FILE_MODE = False
+
+        # Make Base folder
+        if root_dir.is_file():
+            # Get name of parent dir and make name
+            temp = self._modify_name(root_dir.parent.name, "encrypt" if mode == "decrypt" else "decrypt")
+            # Create sub dir
+            base_dir = root_dir.parent.joinpath(temp)
+            base_dir.mkdir(exist_ok=True, parents=True)
+            # Move file to that dir
+            new_path = root_dir.rename(base_dir.joinpath(root_dir.name))
+            root_dir = base_dir  # Make root dir
+            FILE_MODE = True
+        else:
+            root_dir: Path = self._directory_validator(root_dir)
+            base_name: str = self._modify_name(root_dir.name, mode=mode)
+            base_dir: Path = root_dir.parent.joinpath(base_name)
+            base_dir.mkdir(exist_ok=True, parents=True)
+
+        _ljust: int = 17  # Logger ljust value
+
+        # Decrypt / Encrypt
+        for path in root_dir.glob("**/*"):
+            rel_path: Path = path.relative_to(root_dir)
+            rel_path_splited: list[str] = str(rel_path).split(os.sep)
+            rel_path_modified: list[str] = [self._modify_name(x, mode=mode) for x in rel_path_splited]
+            new_path: Path = base_dir.joinpath(*rel_path_modified)
+
+            if path.is_dir():
+                logger.debug(f"{mode.title()}ing Dir:".ljust(_ljust) + f"{path}")
+                new_path.mkdir(exist_ok=True, parents=True)
+                logger.debug(f"{mode.title()}ed Dir:".ljust(_ljust) + f"{new_path}")
+            else:
+                logger.debug(f"{mode.title()}ing File:".ljust(_ljust) + f"{path}")
+                if mode == "decrypt":
+                    self._crypt.File.file_decrypt(path, new_path)  # type: ignore
+                if mode == "encrypt":
+                    self._crypt.File.file_encrypt(path, new_path)  # type: ignore
+                logger.debug(f"{mode.title()}ed File:".ljust(_ljust) + f"{new_path}")
+        logger.info(f"Operation: {mode.title()} COMPLETED")
+
+        # File mode
+        if FILE_MODE:
+            new_path.rename(root_dir.parent.joinpath(new_path.name))  # type: ignore
+            shutil.rmtree(root_dir)
+
+        # Delete when completed
+        if delete_when_complete:
+            logger.debug(f"Deleting {root_dir}")
+            shutil.rmtree(root_dir)
+            logger.debug(f"Deleting {root_dir}...DONE")
+
+    # Decrypt/Encrypt
+    def decrypt(self, root_dir: Path, delete_when_complete: bool = False) -> None:
+        """
+        Decrypt encrypted directory.
+
+        This will decrypt the directory itself and
+        create a decrypted directory next to the original
+
+        Parameters
+        ----------
+        root_dir : Path
+            Directory location
+
+        delete_when_complete : bool, optional
+            Delete directory when completed, by default False
+        """
+        self._decrypt_encrypt_operation(mode="decrypt", root_dir=root_dir, delete_when_complete=delete_when_complete)
+
+    def encrypt(self, root_dir: Path, delete_when_complete: bool = False) -> None:
+        """
+        Encrypt entire directory.
+
+        This will encrypt the directory itself and
+        create an encrypted directory next to the original
+
+        Parameters
+        ----------
+        root_dir : Path
+            Directory location
+
+        delete_when_complete : bool, optional
+            Delete directory when completed, by default False
+        """
+        self._decrypt_encrypt_operation(mode="encrypt", root_dir=root_dir, delete_when_complete=delete_when_complete)
+
+
+class DirectoryRcloneDEMixin(DirectoryBase):
+    """
+    Directory - Rclone encrypt/decrypt
+
+    Extension for ``absfuyu.util.path.Directory``
+
+    - Decrypt
+    - Encrypt
+    """
+
+    def rclone_encrypt(self, passwd: str, salt: str | None = None, delete_when_complete: bool = False) -> None:
+        """
+        Encrypt entire directory.
+
+        This will encrypt the directory itself and
+        create an encrypted directory next to the original
+
+        Parameters
+        ----------
+        passwd : str
+            Custom password
+
+        salt : str | None, optional
+            Custom salt, by default None
+
+        delete_when_complete : bool, optional
+            Delete directory when completed, by default False
+        """
+        engine = RcloneEncryptDecrypt.from_passwd_salt(passwd=passwd, salt=salt)
+        engine.encrypt(self.source_path, delete_when_complete=delete_when_complete)
+
+    def rclone_decrypt(self, passwd: str, salt: str | None = None, delete_when_complete: bool = False) -> None:
+        """
+        Decrypt encrypted directory.
+
+        This will decrypt the directory itself and
+        create a decrypted directory next to the original
+
+        Parameters
+        ----------
+        passwd : str
+            Custom password
+
+        salt : str | None, optional
+            Custom salt, by default None
+
+        delete_when_complete : bool, optional
+            Delete directory when completed, by default False
+        """
+        engine = RcloneEncryptDecrypt.from_passwd_salt(passwd=passwd, salt=salt)
+        engine.decrypt(self.source_path, delete_when_complete=delete_when_complete)
+
+
+# Run
+# -----------------------------------------------------------------------------------------------
+if __name__ == "__main__":
+    logger.setLevel(LogLevel.DEBUG)

absfuyu/extra/xml.py

@@ -0,0 +1,90 @@
+"""
+Absfuyu: XML
+------------
+XML Tool [W.I.P]
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["XML2Dict"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+from pathlib import Path
+from typing import Any, Self
+
+from absfuyu.core.baseclass import GetClassMembersMixin
+
+XML_MODE = False
+
+try:
+    import xmltodict
+except ImportError:
+    from subprocess import run
+
+    from absfuyu.config import ABSFUYU_CONFIG
+
+    if ABSFUYU_CONFIG._get_setting("auto-install-extra").value:  # type: ignore
+        cmd = "python -m pip install -U absfuyu[full]".split()
+        run(cmd)
+    else:
+        raise SystemExit("This feature is in absfuyu[full] package")  # noqa: B904
+else:
+    XML_MODE = True
+
+
+# Class
+# ---------------------------------------------------------------------------
+class XML2Dict(GetClassMembersMixin):
+    """
+    Automatically convert .xml file to dict
+
+
+    Usage
+    -----
+    >>> XML2Dict(<path>)
+    >>> XML2Dict.parsed_data
+    """
+
+    def __init__(self, text: str) -> None:
+        """
+        Automatically convert .xml file to dict
+
+        Parameters
+        ----------
+        text : str
+            ``.xml`` format text
+        """
+        self._text = text
+
+        self.parsed_data: dict[str, Any] = self._parse_xml()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+    def _parse_xml(self) -> dict[str, Any]:
+        """Convert xml to dict"""
+        return xmltodict.parse(self._text, encoding="utf-8")  # type: ignore
+
+    @classmethod
+    def from_path(cls, xml_path: str | Path) -> Self:
+        """
+        Convert from .xml file path
+
+        Parameters
+        ----------
+        xml_path : str | Path
+            Path to .xml file
+
+        Returns
+        -------
+        Self
+            xml to dict
+        """
+        with Path(xml_path).open("r", encoding="utf-8") as f:
+            dat = "\n".join(f.readlines())
+        return cls(dat)

absfuyu/fun/__init__.py

@@ -3,8 +3,8 @@ Absfuyu: Fun
 ------------
 Some fun or weird stuff
 
-Version: 5.6.1
-Date updated: 12/09/2025 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
 
 # Module level
@@ -95,24 +95,6 @@ def zodiac_sign(day: int, month: int, zodiac13: bool = False) -> str:
     return result
 
 
-@deprecated("5.0.0", reason="API shutdown, will be removed later")
-def im_bored() -> str:
-    """
-    Get random activity from ``boredapi`` website
-
-    Returns
-    -------
-    str
-        Random activity
-    """
-    raise SystemExit("API shuted down")
-    # try:
-    #     api = APIRequest("https://www.boredapi.com/api/activity")
-    #     return api.fetch_data_only().json()["activity"]  # type: ignore
-    # except Exception:
-    #     return "FAILED"
-
-
 # For new year only
 def happy_new_year(forced: bool = False, include_lunar: bool = False) -> None:
     """