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

absfuyu/__init__.py

@@ -22,7 +22,7 @@ Using in cmd (`absfuyu[cli]` required):
 __title__ = "absfuyu"
 __author__ = "AbsoluteWinter"
 __license__ = "MIT License"
-__version__ = "4.1.1"
+__version__ = "4.2.0"
 __all__ = [
     "core",
     "config",

absfuyu/cli/__init__.py

@@ -3,8 +3,8 @@ ABSFUYU
 -------
 COMMAND LINE INTERFACE
 
-Version: 1.0.0
-Date updated: 14/04/2024 (dd/mm/yyyy)
+Version: 1.1.0
+Date updated: 09/02/2025 (dd/mm/yyyy)
 """
 
 __all__ = ["cli"]
@@ -19,6 +19,7 @@ from absfuyu.cli.color import COLOR
 from absfuyu.cli.config_group import config_group
 from absfuyu.cli.do_group import do_group
 from absfuyu.cli.game_group import game_group
+from absfuyu.cli.tool_group import tool_group
 
 # Color stuff
 colorama.init(autoreset=True)
@@ -48,4 +49,5 @@ def cli() -> None:
 cli.add_command(config_group)
 cli.add_command(do_group)
 cli.add_command(game_group)
+cli.add_command(tool_group)
 cli.add_command(version)

absfuyu/cli/do_group.py

@@ -3,14 +3,13 @@ ABSFUYU CLI
 -----------
 Do
 
-Version: 1.3.1
-Date updated: 01/02/2025 (dd/mm/yyyy)
+Version: 1.4.0
+Date updated: 07/02/2025 (dd/mm/yyyy)
 """
 
 __all__ = ["do_group"]
 
 import subprocess
-from typing import Literal
 
 import click
 
@@ -18,7 +17,7 @@ from absfuyu import __title__
 from absfuyu.cli.color import COLOR
 from absfuyu.core import __package_feature__
 from absfuyu.general.human import Human2
-from absfuyu.tools.checksum import Checksum
+from absfuyu.tools.shutdownizer import ShutDownizer
 from absfuyu.util.zipped import Zipper
 from absfuyu.version import PkgVersion
 
@@ -82,7 +81,11 @@ def fs(date: str, number_string: str) -> None:
 @click.command(name="info")
 @click.argument("date", type=str)
 def info(date: str) -> None:
-    """Day info"""
+    """
+    Day info, format: yyyymmdd
+
+    Remake this
+    """
 
     instance = Human2(date)
     print(instance.info())
@@ -98,61 +101,11 @@ def unzip_files_in_dir(dir: str) -> None:
     print("Done")
 
 
-@click.command(name="checksum")
-@click.argument("file_path", type=str)
-@click.option(
-    "--hashmode",
-    "-m",
-    "hash_mode",
-    type=click.Choice(["md5", "sha1", "sha256", "sha512"]),
-    default="sha256",
-    show_default=True,
-    help="Hash mode",
-)
-@click.option(
-    "--save-result",
-    "-s",
-    "save_result",
-    type=bool,
-    default=False,
-    is_flag=True,
-    show_default=True,
-    help="Save checksum result to file",
-)
-@click.option(
-    "--recursive",
-    "-r",
-    "recursive_mode",
-    type=bool,
-    default=False,
-    is_flag=True,
-    show_default=True,
-    help="Do checksum for every file in the folder (including child folder)",
-)
-@click.option(
-    "--compare",
-    "-c",
-    "hash_to_compare",
-    type=str,
-    default=None,
-    show_default=True,
-    help="Hash to compare",
-)
-def file_checksum(
-    file_path: str,
-    hash_mode: str | Literal["md5", "sha1", "sha256", "sha512"],
-    save_result: bool,
-    recursive_mode: bool,
-    hash_to_compare: str,
-) -> None:
-    """Checksum for file"""
-    # print(hash_mode, save_result, recursive_mode)
-    instance = Checksum(file_path, hash_mode=hash_mode, save_result_to_file=save_result)
-    res = instance.checksum(recursive=recursive_mode)
-    if hash_to_compare:
-        print(res == hash_to_compare)
-    else:
-        print(res)
+@click.command(name="shutdown")
+def os_shutdown() -> None:
+    """Shutdown"""
+    engine = ShutDownizer()
+    engine.shutdown()
 
 
 @click.group(name="do")
@@ -167,4 +120,4 @@ do_group.add_command(advice)
 do_group.add_command(fs)
 do_group.add_command(info)
 do_group.add_command(unzip_files_in_dir)
-do_group.add_command(file_checksum)
+do_group.add_command(os_shutdown)

absfuyu/cli/tool_group.py

@@ -0,0 +1,136 @@
+"""
+ABSFUYU CLI
+-----------
+Tool
+
+Version: 1.0.0
+Date updated: 10/02/2025 (dd/mm/yyyy)
+"""
+
+__all__ = ["tool_group"]
+
+from typing import Literal
+
+import click
+
+from absfuyu.tools.checksum import Checksum
+from absfuyu.tools.converter import Base64EncodeDecode, Text2Chemistry
+
+
+@click.command(name="checksum")
+@click.argument("file_path", type=str)
+@click.option(
+    "--hashmode",
+    "-m",
+    "hash_mode",
+    type=click.Choice(["md5", "sha1", "sha256", "sha512"]),
+    default="sha256",
+    show_default=True,
+    help="Hash mode",
+)
+@click.option(
+    "--save-result",
+    "-s",
+    "save_result",
+    type=bool,
+    default=False,
+    is_flag=True,
+    show_default=True,
+    help="Save checksum result to file",
+)
+@click.option(
+    "--recursive",
+    "-r",
+    "recursive_mode",
+    type=bool,
+    default=False,
+    is_flag=True,
+    show_default=True,
+    help="Do checksum for every file in the folder (including child folder)",
+)
+@click.option(
+    "--compare",
+    "-c",
+    "hash_to_compare",
+    type=str,
+    default=None,
+    show_default=True,
+    help="Hash to compare",
+)
+def file_checksum(
+    file_path: str,
+    hash_mode: str | Literal["md5", "sha1", "sha256", "sha512"],
+    save_result: bool,
+    recursive_mode: bool,
+    hash_to_compare: str,
+) -> None:
+    """Checksum for file/directory"""
+    # print(hash_mode, save_result, recursive_mode)
+    instance = Checksum(file_path, hash_mode=hash_mode, save_result_to_file=save_result)
+    res = instance.checksum(recursive=recursive_mode)
+    if hash_to_compare:
+        print(res == hash_to_compare)
+    else:
+        print(res)
+
+
+@click.command(name="t2c")
+@click.argument("text", type=str)
+def text2chem(text: str) -> None:
+    """Convert text into chemistry symbol"""
+    engine = Text2Chemistry()
+    out = engine.convert(text)
+    print(Text2Chemistry.beautify_result(out))
+
+
+@click.command(name="e")
+@click.argument("text", type=str)
+def base64encode(text: str) -> None:
+    """Convert text to base64"""
+    print(Base64EncodeDecode.encode(text))
+
+
+@click.command(name="d")
+@click.argument("text", type=str)
+def base64decode(text: str) -> None:
+    """Convert base64 to text"""
+    print(Base64EncodeDecode.decode(text))
+
+
+@click.command(name="img")
+@click.option(
+    "--data-tag",
+    "-d",
+    "data_tag",
+    type=bool,
+    default=False,
+    is_flag=True,
+    show_default=True,
+    help="Add data tag before base64 string",
+)
+@click.argument("img_path", type=str)
+def base64convert_img(img_path: str, data_tag: bool) -> None:
+    """Convert img to base64"""
+    print(Base64EncodeDecode.encode_image(img_path, data_tag=data_tag))
+
+
+@click.group(name="b64")
+def base64_group():
+    """Base64 encode decode"""
+    pass
+
+
+base64_group.add_command(base64encode)
+base64_group.add_command(base64decode)
+base64_group.add_command(base64convert_img)
+
+
+@click.group(name="tool")
+def tool_group() -> None:
+    """Tools"""
+    pass
+
+
+tool_group.add_command(file_checksum)
+tool_group.add_command(base64_group)
+tool_group.add_command(text2chem)

absfuyu/core.py

@@ -3,8 +3,8 @@ Absfuyu: Core
 -------------
 Contain type hints and other stuffs
 
-Version: 2.3.1
-Date updated: 01/02/2025 (dd/mm/yyyy)
+Version: 2.3.2
+Date updated: 11/02/2025 (dd/mm/yyyy)
 """
 
 # Module Package
@@ -18,7 +18,7 @@ __all__ = [
     "DATA_PATH",
 ]
 
-__package_feature__ = ["beautiful", "extra", "res", "full", "dev"]
+__package_feature__ = ["beautiful", "extra", "full", "dev"]
 
 
 # Library

absfuyu/extensions/__init__.py

@@ -1,6 +1,7 @@
 """
 Absfuyu: Extension
 ------------------
+Features that require additional libraries
 
 Version: 1.0.1
 Date updated: 24/11/2023 (dd/mm/yyyy)

absfuyu/pkg_data/__init__.py

@@ -26,9 +26,9 @@ from absfuyu.logger import logger
 ###########################################################################
 _EXTERNAL_DATA = {
     "chemistry.json": "https://raw.githubusercontent.com/Bowserinator/Periodic-Table-JSON/master/PeriodicTableJSON.json",
-    "countries.json": "https://github.com/dr5hn/countries-states-cities-database/blob/master/countries.json",
     "tarot.json": "https://raw.githubusercontent.com/dariusk/corpora/master/data/divination/tarot_interpretations.json",
     "word_list.json": "https://raw.githubusercontent.com/dwyl/english-words/master/words_dictionary.json",
+    # "countries.json": "https://raw.githubusercontent.com/dr5hn/countries-states-cities-database/refs/heads/master/json/countries.json",
 }
 
 
@@ -37,6 +37,7 @@ _EXTERNAL_DATA = {
 class DataList:
     CHEMISTRY = files("absfuyu.pkg_data").joinpath("chemistry.pkl")
     TAROT = files("absfuyu.pkg_data").joinpath("tarot.pkl")
+    PASSWORDLIB = files("absfuyu.pkg_data").joinpath("passwordlib_lzma.pkl")
 
 
 class PkgData:

absfuyu/tools/checksum.py

@@ -3,8 +3,8 @@ Absufyu: Checksum
 -----------------
 Check MD5, SHA256, ...
 
-Version: 1.1.0
-Date updated: 01/02/2025 (dd/mm/yyyy)
+Version: 1.1.1
+Date updated: 05/02/2025 (dd/mm/yyyy)
 """
 
 # Module level
@@ -58,6 +58,17 @@ class Checksum:
         hash_mode: str | Literal["md5", "sha1", "sha256", "sha512"] = "sha256",
         save_result_to_file: bool = False,
     ) -> None:
+        """Checksum engine
+
+        Parameters
+        ----------
+        path : str | Path
+            Path to file/directory to perform checksum
+        hash_mode : str | 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 +120,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 +136,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)
 

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: 1.4.0
+Date updated: 10/02/2025 (dd/mm/yyyy)
 
 Feature:
 --------
@@ -26,6 +26,7 @@ import re
 import string
 from itertools import chain, combinations
 from pathlib import Path
+from typing import Self
 
 from absfuyu.core import CLITextColor
 from absfuyu.logger import logger
@@ -58,7 +59,7 @@ class Base64EncodeDecode:
         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
         -------
@@ -76,8 +77,6 @@ class Base64EncodeDecode:
 class ChemistryElement:
     """Chemistry Element"""
 
-    _VERSION = (1, 1, 0)
-
     def __init__(self, name: str, number: int, symbol: str, atomic_mass: float) -> None:
         """
         name: element name
@@ -111,7 +110,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
 
@@ -159,7 +158,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,6 +230,36 @@ class Text2Chemistry:
 
         return output
 
+    @staticmethod
+    def beautify_result(
+        result: list[list[ChemistryElement]] | list,
+    ) -> str:  # Added in version 4.2.0
+        """Beautify the result from ``Text2Chemistry.convert()``
+
+        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):
+                msg.append(f"Option {i:02}: {', '.join([x.symbol for x in solution])}")
+                for x in solution:
+                    msg.append(
+                        f"{x.symbol} ({x.number}. {x.name} - {round(x.atomic_mass, 2)})"
+                    )
+                msg.append("---")
+            res = "\n".join(msg)
+        return res
+
 
 class Str2Pixel:
     """Convert str into pixel"""

absfuyu/{extensions/dev → tools}/passwordlib.py

@@ -1,36 +1,37 @@
-# type: ignore
-# flake8: noqa
-
 """
 Absfuyu: Passwordlib
 --------------------
 Password library
 
-Version: 1.0.0dev1
-Date updated: 30/11/2023 (dd/mm/yyyy)
+Version: 1.0.0
+Date updated: 11/02/2025 (dd/mm/yyyy)
 """
 
+# Module level
+###########################################################################
+__all__ = ["PasswordGenerator"]
+
+
 # Library
 ###########################################################################
-# from collections import namedtuple
 import hashlib
+import lzma
 import os
 import random
 import re
-from typing import List, Optional
-
-from absfuyu_res import DATA
+from typing import NamedTuple, Optional
 
 from absfuyu.general.data_extension import DictExt, Text
 from absfuyu.general.generator import Charset, Generator
 from absfuyu.logger import logger
+from absfuyu.pkg_data import DataList
 from absfuyu.util import set_min
 from absfuyu.util.pkl import Pickler
 
 
 # Function
 ###########################################################################
-def password_check(password: str) -> bool:
+def _password_check(password: str) -> bool:
     """
     Verify the strength of ``password``.
     A password is considered strong if:
@@ -84,13 +85,13 @@ def password_check(password: str) -> bool:
 
 # Class
 ###########################################################################
-class Password:
-    """Password"""
+class PasswordHash(NamedTuple):
+    salt: bytes
+    key: bytes
 
-    def __init__(self) -> None:
-        """doc_string"""
-        self.password: str = None
-        self._words: List[str] = Pickler.load(DATA.PASSWORDLIB)
+
+class PasswordGenerator:
+    """Password Generator"""
 
     def __str__(self) -> str:
         return f"{self.__class__.__name__}()"
@@ -98,38 +99,31 @@ class Password:
     def __repr__(self) -> str:
         return self.__str__()
 
-    def password_hash(self):
+    @staticmethod
+    def password_hash(password: str) -> PasswordHash:
         """
         Generate hash for password
         """
         salt = os.urandom(32)
         key = hashlib.pbkdf2_hmac(
             hash_name="sha256",
-            password=self.password.encode("utf-8"),
+            password=password.encode("utf-8"),
             salt=salt,
             iterations=100000,
         )
-        out = {
-            "salt": salt,
-            "key": key,
-        }
+        # out = {
+        #     "salt": salt,
+        #     "key": key,
+        # }
+        out = PasswordHash(salt, key)
         return out
 
     @staticmethod
-    def password_check(password: str):
+    def password_check(password: str) -> dict:
         data = Text(password).analyze()
+        data = DictExt(data).apply(lambda x: True if x > 0 else False)  # type: ignore
         data.__setitem__("length", len(password))
-        data = DictExt(data).apply(lambda x: True if x > 0 else False)
-        return data
-
-    @property
-    def words(self) -> List[str]:
-        """
-        Word list to generate passphrase
-
-        :rtype: list[str]
-        """
-        return self._words
+        return dict(data)
 
     # Password generator
     @staticmethod
@@ -187,24 +181,26 @@ class Password:
         while True:
             pwd = Generator.generate_string(
                 charset=charset,
-                size=set_min(length, min_value=8),
+                size=set_min(length, min_value=8),  # type: ignore
                 times=1,
                 string_type_if_1=True,
             )
 
             analyze = Text(pwd).analyze()  # Count each type of char
 
-            s = sum([1 for x in analyze.values() if x > 0])
+            s = sum([1 for x in analyze.values() if x > 0])  # type: ignore
             if s > check:  # Break loop if each type of char has atleast 1
                 break
-        return pwd
+        return pwd  # type: ignore
 
+    @staticmethod
     def generate_passphrase(
-        self,
         num_of_blocks: int = 5,
         block_divider: Optional[str] = None,
         first_letter_cap: bool = True,
         include_number: bool = True,
+        *,
+        custom_word_list: list[str] | None = None,
     ) -> str:
         """
         Generate a random passphrase
@@ -223,6 +219,9 @@ class Password:
         include_number : bool
             Add number to the end of each word (Default: ``True``)
 
+        custom_word_list : list[str] | None
+            Custom word list for passphrase generation, by default uses a list of 360K+ words
+
         Returns
         -------
         str
@@ -234,25 +233,28 @@ class Password:
         >>> print(Password().generate_passphrase())
         Myomectomies7-Sully4-Torpedomen7-Netful2-Begaud8
         """
-
-        def convert_func(value: str):
-            if first_letter_cap:
-                value = value.title()
-            if include_number:
-                value += str(random.choice(range(10)))
-            return value
+        words: list[str] = (
+            (lzma.decompress(Pickler.load(DataList.PASSWORDLIB)).decode().split(","))  # type: ignore
+            if not custom_word_list
+            else custom_word_list
+        )
 
         if not block_divider:
             block_divider = "-"
 
-        return block_divider.join(
-            [convert_func(random.choice(self.words)) for _ in range(num_of_blocks)]
-        )
+        dat = [random.choice(words) for _ in range(num_of_blocks)]
+
+        if first_letter_cap:
+            dat = list(map(lambda x: x.title(), dat))
+
+        if include_number:
+            idx = random.choice(range(5))
+            dat[idx] += str(random.choice(range(10)))
+
+        return block_divider.join(dat)
 
 
 # Run
 ###########################################################################
 if __name__ == "__main__":
     logger.setLevel(10)
-    # print(os.urandom(32))
-    print(Password.password_check(Password.generate_password()))