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

absfuyu/tools/checksum.py

@@ -3,33 +3,35 @@ Absufyu: Checksum
 -----------------
 Check MD5, SHA256, ...
 
-Version: 1.1.0
-Date updated: 01/02/2025 (dd/mm/yyyy)
+Version: 5.0.0
+Date updated: 13/02/2025 (dd/mm/yyyy)
 """
 
 # Module level
-###########################################################################
-__all__ = ["Checksum", "checksum_operation"]
+# ---------------------------------------------------------------------------
+__all__ = ["Checksum", "ChecksumMode"]
 
 
 # Library
-###########################################################################
+# ---------------------------------------------------------------------------
 import hashlib
+from enum import StrEnum
 from pathlib import Path
 from typing import Literal
 
-from absfuyu.core import tqdm
-
-# Function
-###########################################################################
+from absfuyu.core import BaseClass, deprecated, tqdm, versionadded, versionchanged
 
 
-# Deprecated
-def checksum_operation(
+# Function
+# ---------------------------------------------------------------------------
+@deprecated("5.0.0")
+def _checksum_operation(
     file: Path | str,
     hash_mode: str | Literal["md5", "sha1", "sha256", "sha512"] = "sha256",
 ) -> str:
-    """This performs checksum"""
+    """
+    This performs checksum
+    """
     if hash_mode.lower() == "md5":
         hash_engine = hashlib.md5()
     elif hash_mode.lower() == "sha1":
@@ -51,13 +53,39 @@ def checksum_operation(
     return hash_engine.hexdigest()
 
 
-class Checksum:
+# Class
+# ---------------------------------------------------------------------------
+class ChecksumMode(StrEnum):
+    MD5 = "md5"
+    SHA1 = "sha1"
+    SHA256 = "sha256"
+    SHA512 = "sha512"
+
+
+@versionchanged("4.1.1", reason="Checksum for entire folder is possible")
+@versionadded("4.1.0")
+class Checksum(BaseClass):
     def __init__(
         self,
         path: str | Path,
-        hash_mode: str | Literal["md5", "sha1", "sha256", "sha512"] = "sha256",
+        hash_mode: (
+            ChecksumMode | Literal["md5", "sha1", "sha256", "sha512"]
+        ) = ChecksumMode.SHA256,
         save_result_to_file: bool = False,
     ) -> None:
+        """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
+        """
         self.path = Path(path)
         self.hash_mode = hash_mode
         self.save_result_to_file = save_result_to_file
@@ -109,7 +137,7 @@ class Checksum:
         str
             Checksum hash
         """
-        if self.path.absolute().is_dir():
+        if self.path.absolute().is_dir():  # Dir
             new_path = self.path.joinpath(self.checksum_result_file_name)
             # List of files
             if recursive:
@@ -125,7 +153,7 @@ class Checksum:
                 name = x.relative_to(self.path)
                 res.append(f"{self._checksum_operation(x)} | {name}")
             output = "\n".join(res)
-        else:
+        else:  # File
             new_path = self.path.with_name(self.checksum_result_file_name)
             output = self._checksum_operation(self.path)
 
@@ -135,9 +163,3 @@ class Checksum:
                 f.write(output)
 
         return output
-
-
-# Run
-###########################################################################
-if __name__ == "__main__":
-    pass

absfuyu/tools/converter.py

@@ -3,8 +3,8 @@ Absufyu: Converter
 ------------------
 Convert stuff
 
-Version: 1.3.0
-Date updated: 01/02/2025 (dd/mm/yyyy)
+Version: 5.0.0
+Date updated: 11/02/2025 (dd/mm/yyyy)
 
 Feature:
 --------
@@ -14,51 +14,61 @@ Feature:
 """
 
 # Module level
-###########################################################################
-__all__ = ["Text2Chemistry", "Str2Pixel", "Base64EncodeDecode"]
+# ---------------------------------------------------------------------------
+__all__ = [
+    "Text2Chemistry",
+    "Str2Pixel",
+    "Base64EncodeDecode",
+]
 
 
 # Library
-###########################################################################
+# ---------------------------------------------------------------------------
 import base64
 import math
 import re
 import string
 from itertools import chain, combinations
 from pathlib import Path
+from typing import Self
 
-from absfuyu.core import CLITextColor
+from absfuyu.core import BaseClass, CLITextColor, versionadded
 from absfuyu.logger import logger
-from absfuyu.pkg_data import DataList
+from absfuyu.pkg_data import DataList, DataLoader
 from absfuyu.util import set_min
-from absfuyu.util.pkl import Pickler
 
 
 # Class
-###########################################################################
-class Base64EncodeDecode:
+# ---------------------------------------------------------------------------
+@versionadded("3.0.0")
+class Base64EncodeDecode(BaseClass):
     """
     Encode and decode base64
     """
 
     @staticmethod
     def encode(data: str) -> str:
+        """Base64 encode"""
         return base64.b64encode(data.encode()).decode()
 
     @staticmethod
     def decode(data: str) -> str:
+        """Base64 decode"""
         return base64.b64decode(data).decode()
 
     @staticmethod
+    @versionadded("4.1.0")
     def encode_image(img_path: Path | str, data_tag: bool = False) -> str:
-        """Encode image file into base64 string
+        """
+        Encode image file into base64 string
 
         Parameters
         ----------
         img_path : Path | str
             Path to image
+
         data_tag : bool, optional
-            Add data tag before base64 string, by default False
+            Add data tag before base64 string, by default ``False``
 
         Returns
         -------
@@ -73,11 +83,9 @@ class Base64EncodeDecode:
         return b64_data
 
 
-class ChemistryElement:
+class ChemistryElement(BaseClass):
     """Chemistry Element"""
 
-    _VERSION = (1, 1, 0)
-
     def __init__(self, name: str, number: int, symbol: str, atomic_mass: float) -> None:
         """
         name: element name
@@ -91,10 +99,6 @@ class ChemistryElement:
         self.atomic_mass = atomic_mass
 
     def __str__(self) -> str:
-        return self.symbol
-
-    def __repr__(self) -> str:
-        # return self.symbol
         return f"{self.__class__.__name__}({self.symbol})"
 
     def to_dict(self) -> dict[str, str | int | float]:
@@ -111,7 +115,7 @@ class ChemistryElement:
         }
 
     @classmethod
-    def from_dict(cls, data: dict[str, str | int | float]) -> "ChemistryElement":
+    def from_dict(cls, data: dict[str, str | int | float]) -> Self:
         """
         Convert from ``dict`` data
 
@@ -127,25 +131,22 @@ class ChemistryElement:
         )
 
 
-class Text2Chemistry:
+class Text2Chemistry(BaseClass):
     def __init__(self) -> None:
         self.data_location = DataList.CHEMISTRY
 
     def __str__(self) -> str:
         return f"{self.__class__.__name__}()"
 
-    def __repr__(self) -> str:
-        return self.__str__()
-
     def _load_chemistry_data(self) -> list[ChemistryElement]:
         """
         Load chemistry pickle data
         """
-        data: list[dict] = Pickler.load(self.data_location)  # type: ignore
+        data: list[dict] = DataLoader(self.data_location).load()
         return [ChemistryElement.from_dict(x) for x in data]
 
     @property
-    def unvailable_characters(self):
+    def unvailable_characters(self) -> set[str]:
         """
         Characters that can not be converted (unvailable chemistry symbol)
 
@@ -159,7 +160,7 @@ class Text2Chemistry:
         # logger.debug(available)
         return base.difference(available)
 
-    def convert(self, text: str) -> list[list[ChemistryElement]]:
+    def convert(self, text: str) -> list[list[ChemistryElement]] | list:
         """
         Convert text to chemistry symbol
 
@@ -231,8 +232,41 @@ class Text2Chemistry:
 
         return output
 
+    @staticmethod
+    @versionadded("4.2.0")
+    def beautify_result(
+        result: list[list[ChemistryElement]] | list,
+    ) -> str:
+        """
+        Beautify the result from ``Text2Chemistry.convert()``
 
-class Str2Pixel:
+        Parameters
+        ----------
+        result : list[list[ChemistryElement]] | list
+            Convert ``Text2Chemistry.convert()`` result
+
+        Returns
+        -------
+        str
+            Beautified output
+        """
+        if len(result) == 0:
+            res = "No possible combination"
+        else:
+            msg = []
+            for i, solution in enumerate(result, start=1):
+                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)})"
+                    )
+                msg.append("---")
+            res = "\n".join(msg)
+        return res
+
+
+class Str2Pixel(BaseClass):
     """Convert str into pixel"""
 
     PIXEL = "\u2588"
@@ -245,11 +279,17 @@ class Str2Pixel:
         pixel_symbol_overwrite: str | None = None,
     ) -> None:
         """
-        str_data: Pixel string data (Format: <number_of_pixel><color_code>)
-        pixel_size: Pixel size (Default: 2)
-        pixel_symbol_overwrite: Overwrite pixel symbol (Default: None)
+        Parameters
+        ----------
+        str_data : str
+            Pixel string data (Format: ``<number_of_pixel><color_code>``)
+            Example: 50w20b = 50 white pixels and 20 black pixels
 
-        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``
         """
         self.data = str_data
         if pixel_symbol_overwrite is None:
@@ -257,12 +297,6 @@ class Str2Pixel:
         else:
             self.pixel = pixel_symbol_overwrite
 
-    def __str__(self) -> str:
-        return f"{self.__class__.__name__}(pixel={self.pixel})"
-
-    def __repr__(self) -> str:
-        return self.__str__()
-
     def _extract_pixel(self):
         """Split str_data into corresponding int and str"""
         num = re.split("[a-zA-Z]", self.data)  # type: ignore
@@ -273,13 +307,17 @@ class Str2Pixel:
         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
 
-        :param line_break: add ``\\n`` at the end of line (Default: ``False``)
-        :type line_break: bool
-        :returns: Converted colored pixels
-        :rtype: str
+        Parameters
+        ----------
+        line_break : bool, optional
+            Add ``\\n`` at the end of line, by default ``True``
+
+        Returns
+        -------
+        str
+            Converted colored pixels
         """
         # Extract pixel
         pixel_map = self._extract_pixel()
@@ -324,9 +362,3 @@ class Str2Pixel:
             return out + "\n"
         else:
             return out
-
-
-# Run
-###########################################################################
-if __name__ == "__main__":
-    logger.setLevel(10)

absfuyu/tools/keygen.py

@@ -5,23 +5,25 @@ Mod7 product key generator (90's)
 
 This is for educational and informative purposes only.
 
-Version: 2.0.2
-Date updated: 05/04/2024 (dd/mm/yyyy)
+Version: 5.0.0
+Date updated: 25/02/2025 (dd/mm/yyyy)
 """
 
 # Module level
-###########################################################################
+# ---------------------------------------------------------------------------
 __all__ = ["Keygen"]
 
 
 # Library
-###########################################################################
+# ---------------------------------------------------------------------------
 import random
 
+from absfuyu.core import BaseClass
+
 
 # Class
-###########################################################################
-class Keygen:
+# ---------------------------------------------------------------------------
+class Keygen(BaseClass):
     """Key generator"""
 
     @staticmethod
@@ -39,8 +41,8 @@ class Keygen:
         except Exception:
             raise ValueError("Invalid string")  # noqa: B904
 
-    @staticmethod
-    def _mod7_gen(num_of_digits: int, *, fillchar: str = "0") -> str:
+    @classmethod
+    def _mod7_gen(cls, num_of_digits: int, *, fillchar: str = "0") -> str:
         """
         Generate a number with desired length that is divisible by 7
 
@@ -76,14 +78,14 @@ class Keygen:
                 continue
 
             # Check divide by 7
-            if __class__._is_mod7(mod7_num):  # type: ignore
+            if cls._is_mod7(str(mod7_num)):
                 mod7_valid = True
 
         # Output
         return str(mod7_num).rjust(num_of_digits, fillchar)
 
-    @staticmethod
-    def mod7_cd_key(fast: bool = False) -> str:
+    @classmethod
+    def mod7_cd_key(cls, fast: bool = False) -> str:
         """
         CD Key generator
 
@@ -123,13 +125,13 @@ class Keygen:
                 part1_valid = True  # Break loop
 
         # PART 02
-        part2 = __class__._mod7_gen(num_of_digits=7)  # type: ignore
+        part2 = cls._mod7_gen(num_of_digits=7)
 
         # OUTPUT
         return f"{part1}-{part2}"
 
-    @staticmethod
-    def mod7_11_digit_key(fast: bool = False) -> str:
+    @classmethod
+    def mod7_11_digit_key(cls, fast: bool = False) -> str:
         """
         11-digit CD Key generator
 
@@ -171,13 +173,13 @@ class Keygen:
                 part1_valid = True
 
         # PART 02
-        part2 = __class__._mod7_gen(num_of_digits=7)  # type: ignore
+        part2 = cls._mod7_gen(num_of_digits=7)
 
         # OUTPUT
         return f"{part1}-{part2}"
 
-    @staticmethod
-    def mod7_oem_key(fast: bool = False) -> str:
+    @classmethod
+    def mod7_oem_key(cls, fast: bool = False) -> str:
         """
         OEM Key generator
 
@@ -214,7 +216,7 @@ class Keygen:
         y_part = random.choice(year_choice)
 
         # NUM PART
-        num_part = __class__._mod7_gen(num_of_digits=6)  # type: ignore
+        num_part = cls._mod7_gen(num_of_digits=6)
 
         # NUM PART 02
         num_part_2 = str(random.randint(0, 99999)).rjust(5, "0")
@@ -222,8 +224,8 @@ class Keygen:
         # OUTPUT
         return f"{abc_part}{y_part}-OEM-0{num_part}-{num_part_2}"
 
-    @staticmethod
-    def mod7_combo(fast: bool = False):
+    @classmethod
+    def mod7_combo(cls, fast: bool = False):
         """
         A combo that consist of CD, 11-digit, and OEM Key
 
@@ -239,15 +241,8 @@ class Keygen:
             Mod7 Key combo
         """
         out = {
-            "CD Key": __class__.mod7_cd_key(fast=fast),  # type: ignore
-            "OEM Key": __class__.mod7_oem_key(fast=fast),  # type: ignore
-            "11-digit Key": __class__.mod7_11_digit_key(fast=fast),  # type: ignore
+            "CD Key": cls.mod7_cd_key(fast=fast),
+            "OEM Key": cls.mod7_oem_key(fast=fast),
+            "11-digit Key": cls.mod7_11_digit_key(fast=fast),
         }
         return out
-
-
-# Run
-###########################################################################
-if __name__ == "__main__":
-    test = Keygen()
-    print(test.mod7_combo())