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

absfuyu/__init__.py

@@ -15,19 +15,19 @@ Normal import:
 >>> import absfuyu
 >>> help(absfuyu)
 
-Using in cmd (`absfuyu[cli]` required):
+Using in cmd:
 ``$ fuyu --help``
 """
 
 __title__ = "absfuyu"
 __author__ = "AbsoluteWinter"
 __license__ = "MIT License"
-__version__ = "4.2.0"
+__version__ = "5.0.0"
 __all__ = [
     "core",
     "config",
-    "everything",
-    "extensions",
+    "dxt",
+    "extra",
     "logger",
     "fun",
     "game",

absfuyu/__main__.py

@@ -2,14 +2,26 @@
 ABSFUYU
 -------
 COMMAND LINE INTERFACE
+
+Version: 5.0.0
+Date updated: 18/02/2025 (dd/mm/yyyy)
 """
 
-from absfuyu.cli import cli
+# Library
+# ---------------------------------------------------------------------------
+try:
+    from absfuyu.cli import cli
+except ModuleNotFoundError:  # Check for `click`, `colorama`
+    from absfuyu.core.dummy_cli import cli
 
 
+# Function
+# ---------------------------------------------------------------------------
 def main() -> None:
     cli()
 
 
+# Run
+# ---------------------------------------------------------------------------
 if __name__ == "__main__":
     main()

absfuyu/cli/color.py

@@ -7,10 +7,17 @@ Version: 1.0.0
 Date updated: 14/04/2024 (dd/mm/yyyy)
 """
 
+# Module Package
+# ---------------------------------------------------------------------------
 __all__ = ["COLOR"]
 
+
+# Library
+# ---------------------------------------------------------------------------
 import colorama
 
+# Color
+# ---------------------------------------------------------------------------
 COLOR = {
     "green": colorama.Fore.LIGHTGREEN_EX,
     "GREEN": colorama.Fore.GREEN,

absfuyu/cli/do_group.py

@@ -16,7 +16,6 @@ import click
 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.shutdownizer import ShutDownizer
 from absfuyu.util.zipped import Zipper
 from absfuyu.version import PkgVersion
@@ -60,37 +59,6 @@ def install(pkg: str) -> None:
         click.echo(f"{COLOR['green']}absfuyu[{pkg}] installed")
 
 
-@click.command()
-def advice() -> None:
-    """Give some recommendation when bored"""
-    from absfuyu.fun import im_bored
-
-    click.echo(f"{COLOR['green']}{im_bored()}")
-
-
-@click.command(name="fs")
-@click.argument("date", type=str)
-@click.argument("number_string", type=str)
-def fs(date: str, number_string: str) -> None:
-    """Feng-shui W.I.P"""
-
-    instance = Human2(date)
-    print(instance.fs(number_string))
-
-
-@click.command(name="info")
-@click.argument("date", type=str)
-def info(date: str) -> None:
-    """
-    Day info, format: yyyymmdd
-
-    Remake this
-    """
-
-    instance = Human2(date)
-    print(instance.info())
-
-
 @click.command(name="unzip")
 @click.argument("dir", type=str)
 def unzip_files_in_dir(dir: str) -> None:
@@ -116,8 +84,5 @@ def do_group() -> None:
 
 do_group.add_command(update)
 do_group.add_command(install)
-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(os_shutdown)

absfuyu/cli/tool_group.py

@@ -59,19 +59,19 @@ from absfuyu.tools.converter import Base64EncodeDecode, Text2Chemistry
 )
 def file_checksum(
     file_path: str,
-    hash_mode: str | Literal["md5", "sha1", "sha256", "sha512"],
+    hash_mode: Literal["md5", "sha1", "sha256", "sha512"],
     save_result: bool,
     recursive_mode: bool,
-    hash_to_compare: str,
+    hash_to_compare: str | None,
 ) -> 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:
+    if hash_to_compare is None:
         print(res)
+    else:
+        print(res == hash_to_compare)
 
 
 @click.command(name="t2c")

absfuyu/config/__init__.py

@@ -3,34 +3,37 @@ Absfuyu: Configuration
 ----------------------
 Package configuration module
 
-Version: 2.0.5
-Date updated: 14/11/2024 (dd/mm/yyyy)
+Version: 5.0.0
+Date updated: 12/02/2025 (dd/mm/yyyy)
 """
 
 # Module level
-###########################################################################
+# ---------------------------------------------------------------------------
 __all__ = [
     "ABSFUYU_CONFIG",
     "Config",
+    "CONFIG_PATH",
     # "Setting"
 ]
 
 
 # Library
-###########################################################################
+# ---------------------------------------------------------------------------
+from importlib.resources import files
 from pathlib import Path
 from typing import Any, TypedDict
 
-from absfuyu.core import CONFIG_PATH
+from absfuyu.core import BaseClass
 from absfuyu.util.json_method import JsonFile
 
 # Setting
-###########################################################################
+# ---------------------------------------------------------------------------
+CONFIG_PATH = files("absfuyu.config").joinpath("config.json")
 _SPACE_REPLACE = "-"  # Replace " " character in setting name
 
 
 # Type hint
-###########################################################################
+# ---------------------------------------------------------------------------
 class SettingDictFormat(TypedDict):
     """
     Format for the ``setting`` section in ``config``
@@ -59,8 +62,8 @@ class ConfigFormat(TypedDict):
 
 
 # Class
-###########################################################################
-class Setting:
+# ---------------------------------------------------------------------------
+class Setting(BaseClass):
     """Setting"""
 
     def __init__(self, name: str, value: Any, default: Any, help_: str = "") -> None:
@@ -78,9 +81,6 @@ class Setting:
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({self.name}: {self.value})"
 
-    def __repr__(self) -> str:
-        return self.__str__()
-
     @classmethod
     def from_dict(cls, dict_data: dict[str, SettingDictFormat]):
         """
@@ -114,7 +114,7 @@ class Setting:
         return output
 
 
-class Config:
+class Config(BaseClass):
     """
     Config handling
     """
@@ -126,10 +126,10 @@ class Config:
         self.config_path: Path = config_file
         self.json_engine: JsonFile = JsonFile(self.config_path)
 
-        if name:
-            self.name = name
-        else:
+        if name is None:
             self.name = self.config_path.name
+        else:
+            self.name = name
 
         # Data
         self.settings: list[Setting] = None  # type: ignore
@@ -138,9 +138,6 @@ class Config:
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({self.config_path.name})"
 
-    def __repr__(self) -> str:
-        return self.__str__()
-
     # Data prepare and export
     def _fetch_data(self) -> None:
         """Load data from ``self.config_file`` file"""
@@ -275,19 +272,5 @@ class Config:
 
 
 # Init
-###########################################################################
+# ---------------------------------------------------------------------------
 ABSFUYU_CONFIG = Config(CONFIG_PATH)  # type: ignore
-
-# TODO: Create a config file when not available [W.I.P]
-# _settings = [
-#     Setting(
-#         "auto-install-extra", False, False, "Automatically install required packages"
-#     ),
-#     Setting("first-run", True, True, "Check if this package has ever been run"),
-#     Setting(
-#         "luckgod-mode",
-#         False,
-#         False,
-#         "A chance that the machine will be randomly shutdown",
-#     ),
-# ]

absfuyu/core/__init__.py

@@ -0,0 +1,49 @@
+"""
+Absfuyu: Core
+-------------
+Bases for other features
+
+Version: 5.0.0
+Date updated: 13/02/2025 (dd/mm/yyyy)
+"""
+
+# Module Package
+# ---------------------------------------------------------------------------
+__all__ = [
+    # color
+    "CLITextColor",
+    # path
+    # "CORE_PATH",
+    # class
+    "ShowAllMethodsMixin",
+    "BaseClass",
+    # wrapper
+    "tqdm",
+    "unidecode",
+    # decorator
+    "deprecated",
+    "versionadded",
+    "versionchanged",
+]
+
+__package_feature__ = [
+    "beautiful",  # BeautifulOutput
+    "docs",  # For (package) hatch's env use only
+    "extra",  # DataFrame
+    "full",  # All package
+    "dev",
+]
+
+
+# Library
+# ---------------------------------------------------------------------------
+# from importlib.resources import files
+
+# Most used features are imported to core
+from absfuyu.core.baseclass import BaseClass, CLITextColor, ShowAllMethodsMixin
+from absfuyu.core.docstring import deprecated, versionadded, versionchanged
+from absfuyu.core.dummy_func import tqdm, unidecode
+
+# Path
+# ---------------------------------------------------------------------------
+# CORE_PATH = files("absfuyu")

absfuyu/core/baseclass.py

@@ -0,0 +1,299 @@
+"""
+Absfuyu: Core
+-------------
+Bases for other features
+
+Version: 5.0.0
+Date updated: 12/02/2025 (dd/mm/yyyy)
+"""
+
+# Module Package
+# ---------------------------------------------------------------------------
+__all__ = [
+    # Color
+    "CLITextColor",
+    # Mixins
+    "ShowAllMethodsMixin",
+    "AutoREPRMixin",
+    # Class
+    "BaseClass",
+    # Metaclass
+    "PositiveInitArgsMeta",
+]
+
+
+# Color
+# ---------------------------------------------------------------------------
+class CLITextColor:
+    """Color code for text in terminal"""
+
+    WHITE = "\x1b[37m"
+    BLACK = "\x1b[30m"
+    BLUE = "\x1b[34m"
+    GRAY = "\x1b[90m"
+    GREEN = "\x1b[32m"
+    RED = "\x1b[91m"
+    DARK_RED = "\x1b[31m"
+    MAGENTA = "\x1b[35m"
+    YELLOW = "\x1b[33m"
+    RESET = "\x1b[39m"
+
+
+# Mixins
+# ---------------------------------------------------------------------------
+class ShowAllMethodsMixin:
+    """
+    Show all methods of the class and its parent class minus ``object`` class
+
+    *This class is meant to be used with other class*
+    """
+
+    @classmethod
+    def show_all_methods(
+        cls,
+        include_classmethod: bool = True,
+        classmethod_indicator: str = "<classmethod>",
+        include_staticmethod: bool = True,
+        staticmethod_indicator: str = "<staticmethod>",
+        include_private_method: bool = False,
+        print_result: bool = False,
+    ) -> dict[str, list[str]]:
+        """
+        Class method to display all methods of the class and its parent classes,
+        including the class in which they are defined in alphabetical order.
+
+        Parameters
+        ----------
+        include_classmethod : bool, optional
+            Whether to include classmethod in the output, by default ``True``
+
+        classmethod_indicator : str, optional
+            A string used to mark classmethod in the output. This string is appended
+            to the name of each classmethod to visually differentiate it from regular
+            instance methods, by default ``"<classmethod>"``
+
+        include_staticmethod : bool, optional
+            Whether to include staticmethod in the output, by default ``True``
+
+        staticmethod_indicator : str, optional
+            A string used to mark staticmethod in the output. This string is appended
+            to the name of each staticmethod to visually differentiate it from regular
+            instance methods, by default ``"<staticmethod>"``
+
+        include_private_method : bool, optional
+            Whether to include private method in the output, by default ``False``
+
+        print_result : bool, optional
+            Beautifully print the output, by default ``False``
+
+        Returns
+        -------
+        dict[str, list[str]]
+            A dictionary where keys are class names and values are lists of method names.
+        """
+        classes = cls.__mro__[::-1][1:]  # MRO in reverse order
+        result = {}
+        for base in classes:
+            methods = []
+            for name, attr in base.__dict__.items():
+                # Skip private attribute
+                if name.startswith("__"):
+                    continue
+
+                # Skip private Callable
+                if base.__name__ in name and not include_private_method:
+                    continue
+
+                # Function
+                if callable(attr):
+                    if isinstance(attr, staticmethod):
+                        if include_staticmethod:
+                            methods.append(f"{name} {staticmethod_indicator}")
+                    else:
+                        methods.append(name)
+                if isinstance(attr, classmethod) and include_classmethod:
+                    methods.append(f"{name} {classmethod_indicator}")
+
+            if methods:
+                result[base.__name__] = sorted(methods)
+
+        if print_result:
+            cls.__print_show_all_result(result)
+
+        return result
+
+    @classmethod
+    def show_all_properties(cls, print_result: bool = False) -> dict[str, list[str]]:
+        """
+        Class method to display all properties of the class and its parent classes,
+        including the class in which they are defined in alphabetical order.
+
+        Parameters
+        ----------
+        print_result : bool, optional
+            Beautifully print the output, by default ``False``
+
+        Returns
+        -------
+        dict[str, list[str]]
+            A dictionary where keys are class names and values are lists of property names.
+        """
+        classes = cls.__mro__[::-1][1:]  # MRO in reverse order
+        result = {}
+        for base in classes:
+            properties = []
+            for name, attr in base.__dict__.items():
+                # Skip private attribute
+                if name.startswith("__"):
+                    continue
+
+                if isinstance(attr, property):
+                    properties.append(name)
+
+            if properties:
+                result[base.__name__] = sorted(properties)
+
+        if print_result:
+            cls.__print_show_all_result(result)
+
+        return result
+
+    @staticmethod
+    def __print_show_all_result(result: dict[str, list[str]]) -> None:
+        """
+        Pretty print the result of ``ShowAllMethodsMixin.show_all_methods()``
+
+        Parameters
+        ----------
+        result : dict[str, list[str]]
+            Result of ``ShowAllMethodsMixin.show_all_methods()``
+        """
+        print_func = print  # Can be extended with function parameter
+
+        # Loop through each class base
+        for order, (class_base, methods) in enumerate(result.items(), start=1):
+            mlen = len(methods)  # How many methods in that class
+            print_func(f"{order:02}. <{class_base}> | len: {mlen:02}")
+
+            # Modify methods list
+            max_method_name_len = max([len(x) for x in methods])
+            if mlen % 2 == 0:
+                p1, p2 = methods[: int(mlen / 2)], methods[int(mlen / 2) :]
+            else:
+                p1, p2 = methods[: int(mlen / 2) + 1], methods[int(mlen / 2) + 1 :]
+                p2.append("")
+            new_methods = list(zip(p1, p2))
+
+            # This print 2 methods in 1 line
+            for x1, x2 in new_methods:
+                if x2 == "":
+                    print_func(f"    - {x1.ljust(max_method_name_len)}")
+                else:
+                    print_func(
+                        f"    - {x1.ljust(max_method_name_len)}    - {x2.ljust(max_method_name_len)}"
+                    )
+
+            # This print 1 method in one line
+            # for name in methods:
+            #     print(f"    - {name.ljust(max_method_name_len)}")
+
+            print_func("".ljust(88, "-"))
+
+
+class AutoREPRMixin:
+    """
+    Generate ``repr()`` output as ``<class(param1=any, param2=any, ...)>``
+
+    *This class is meant to be used with other class*
+
+
+    Example:
+    --------
+    >>> class Test(AutoREPRMixin):
+    ...     def __init__(self, param):
+    ...         self.param = param
+    >>> print(repr(Test(1)))
+    Test(param=1)
+    """
+
+    def __repr__(self) -> str:
+        """
+        Generate a string representation of the instance's attributes.
+
+        This function retrieves attributes from either the ``__dict__`` or
+        ``__slots__`` of the instance, excluding private attributes (those
+        starting with an underscore). The attributes are returned as a
+        formatted string, with each attribute represented as ``"key=value"``.
+
+        Convert ``self.__dict__`` from ``{"a": "b"}`` to ``a=repr(b)``
+        or ``self.__slots__`` from ``("a",)`` to ``a=repr(self.a)``
+        (excluding private attributes)
+        """
+        # Default output
+        out = []
+        sep = ", "  # Separator
+
+        # Get attributes
+        cls_dict = getattr(self, "__dict__", None)
+        cls_slots = getattr(self, "__slots__", None)
+
+        # Check if __dict__ exist and len(__dict__) > 0
+        if cls_dict is not None and len(cls_dict) > 0:
+            out = [
+                f"{k}={repr(v)}"
+                for k, v in self.__dict__.items()
+                if not k.startswith("_")
+            ]
+
+        # Check if __slots__ exist and len(__slots__) > 0
+        elif cls_slots is not None and len(cls_slots) > 0:
+            out = [
+                f"{x}={repr(getattr(self, x))}"
+                for x in self.__slots__  # type: ignore
+                if not x.startswith("_")
+            ]
+
+        # Return out
+        return f"{self.__class__.__name__}({sep.join(out)})"
+
+
+# Class
+# ---------------------------------------------------------------------------
+class BaseClass(ShowAllMethodsMixin, AutoREPRMixin):
+    """Base class"""
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __format__(self, format_spec: str) -> str:
+        """
+        Formats the object according to the specified format.
+        If no format_spec is provided, returns the object's string representation.
+        (Currently a dummy function)
+
+        Usage
+        -----
+        >>> print(f"{<object>:<format_spec>}")
+        >>> print(<object>.__format__(<format_spec>))
+        >>> print(format(<object>, <format_spec>))
+        """
+
+        return self.__str__()
+
+
+# Metaclass
+# ---------------------------------------------------------------------------
+class PositiveInitArgsMeta(type):
+    """Make sure that every args in a class __init__ is positive"""
+
+    def __call__(cls, *args, **kwargs):
+        # Check if all positional and keyword arguments are positive
+        for arg in args:
+            if isinstance(arg, (int, float)) and arg < 0:
+                raise ValueError(f"Argument {arg} must be positive")
+        for key, value in kwargs.items():
+            if isinstance(value, (int, float)) and value < 0:
+                raise ValueError(f"Argument {key}={value} must be positive")
+
+        # Call the original __init__ method
+        return super().__call__(*args, **kwargs)