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

absfuyu/tools/web.py

@@ -3,21 +3,14 @@ Absfuyu: Web
 ------------
 Web, ``request``, ``BeautifulSoup`` stuff
 
-Version: 1.0.2
-Date updated: 05/04/2024 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
 
-# Library
-# ---------------------------------------------------------------------------
-import requests
-from bs4 import BeautifulSoup
-
-from absfuyu.logger import logger
-
 
 # Function
 # ---------------------------------------------------------------------------
-def soup_link(link: str) -> BeautifulSoup:
+def soup_link(link: str):
     """
     ``BeautifulSoup`` the link
 
@@ -32,12 +25,17 @@ def soup_link(link: str) -> BeautifulSoup:
         ``BeautifulSoup`` instance
     """
     try:
+        import requests
+        from bs4 import BeautifulSoup
+
         page = requests.get(link)
         soup = BeautifulSoup(page.content, "html.parser")
-        logger.debug("Soup completed!")
         return soup
+
+    except ImportError:
+        raise ImportError("Please install bs4, requests package")
+
     except Exception:
-        logger.error("Can't soup")
         raise SystemExit("Something wrong")  # noqa: B904
 
 
@@ -51,5 +49,4 @@ def gen_random_commit_msg() -> str:
         Random commit message
     """
     out = soup_link("https://whatthecommit.com/").get_text()[34:-20]
-    logger.debug(out)
     return out  # type: ignore

absfuyu/typings.py

@@ -0,0 +1,138 @@
+"""
+Absfuyu: Core
+-------------
+Pre-defined typing
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module Package
+# ---------------------------------------------------------------------------
+__all__ = [
+    # Type
+    "T",
+    "T_co",
+    "T_contra",
+    "KT",
+    "VT",
+    "P",
+    "R",
+    "_CALLABLE",
+    "CT",
+    "N",
+    "_Number",
+    "override",
+    # Protocol
+    "SupportsShowMethods",
+]
+
+
+# Library
+# ---------------------------------------------------------------------------
+from collections.abc import Callable
+from typing import Any, ParamSpec, Protocol, TypeVar, overload
+
+# Type
+# ---------------------------------------------------------------------------
+# Types where neither is possible are invariant
+# Type safety must be strict
+T = TypeVar("T")  # Type invariant
+# Type variables that are covariant can be substituted
+# with a more specific type without causing errors
+# Safe to treat a Box[int] as a Box[object]
+T_co = TypeVar("T_co", covariant=True)  # Type covariant
+# Type variables that are contravariant can be substituted
+# with a more general type without causing errors
+# Safe to use a Box[object] where a Box[int] is needed
+T_contra = TypeVar("T_contra", contravariant=True)  # Type contravariant
+
+KT = TypeVar("KT")
+VT = TypeVar("VT")
+
+# Callable
+P = ParamSpec("P")  # Parameter type
+R = TypeVar("R")  # Return type - Can be anything
+_CALLABLE = Callable[P, R]
+
+# Class type - Can be any subtype of `type`
+CT = TypeVar("CT", bound=type)
+
+# Number type
+N = TypeVar("N", int, float)  # Must be int or float
+_Number = int | float
+
+
+# Protocol
+# ---------------------------------------------------------------------------
+class SupportsShowMethods(Protocol):
+    """
+    Support class with ``show_all_methods()``
+    and ``show_all_properties()`` method
+    from ``absfuyu.core.basclass.ShowAllMethodsMixin``
+    """
+
+    @overload
+    @classmethod
+    def show_all_methods(cls) -> dict[str, list[str]]: ...
+
+    @overload
+    @classmethod
+    def show_all_methods(
+        cls,
+        print_result: bool = False,
+        include_classmethod: bool = True,
+        classmethod_indicator: str = "<classmethod>",
+        include_staticmethod: bool = True,
+        staticmethod_indicator: str = "<staticmethod>",
+        include_private_method: bool = False,
+    ) -> dict[str, list[str]]: ...
+
+    @classmethod
+    def show_all_methods(cls, *args, **kwargs) -> Any: ...
+
+    @overload
+    @classmethod
+    def show_all_properties(cls) -> dict[str, list[str]]: ...
+
+    @overload
+    @classmethod
+    def show_all_properties(
+        cls, print_result: bool = False
+    ) -> dict[str, list[str]]: ...
+
+    @classmethod
+    def show_all_properties(cls, *args, **kwargs) -> Any: ...
+
+
+# Note
+# ---------------------------------------------------------------------------
+# Iterable                               : __iter__
+# Iterator(Iterable)                     : __next__, __iter__
+# Reversible(Iterable)                   : __reversed__, __iter__
+# Sized                                  : __len__
+# Container                              : __contains__
+# Collection(Sized, Iterable, Container) : __len__, __iter__, __contains__
+# Set(Collection)                        : __contains__, __iter__, __len__
+# MutableSet(Set)                        : __contains__, __iter__, __len__
+# Mapping(Collection)                    : __getitem__, __iter__, and __len__
+# MutableMapping(Mapping)                : __getitem__, __setitem__, __delitem__,__iter__, __len__
+# Sequence(Reversible, Collection)       : __reversed__, __len__, __iter__, __contains__
+# MutableSequence(Sequence)              : __getitem__, __setitem__, __delitem__, __reversed__, __len__, __iter__, __contains__
+
+# Iterable                               : str, dict, list, tuple, set
+# Iterator(Iterable)                     : Generator
+# Reversible(Iterable)                   : str, dict, list, tuple
+# Sized                                  : str, dict, list, tuple, set
+# Container                              : str, dict, list, tuple, set
+# Collection(Sized, Iterable, Container) : str, dict, list, tuple, set
+# Set(Collection)                        : set
+# MutableSet(Set)                        : set
+# Mapping(Collection)                    : dict
+# MutableMapping(Mapping)                : dict
+# Sequence(Reversible, Collection)       : str, list, tuple
+# MutableSequence(Sequence)              : list
+
+# __iter__: for <...> in <...>
+# __len__: len(<...>)
+# __contains__: if <...> in <...>

absfuyu/util/__init__.py

@@ -3,16 +3,34 @@ Absufyu: Utilities
 ------------------
 Some random utilities
 
-Version: 1.5.2
-Date updated: 25/11/2024 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
 
+# Module Package
+# ---------------------------------------------------------------------------
+__all__ = [
+    # util
+    "get_installed_package",
+    "set_min",
+    "set_max",
+    "set_min_max",
+    "stop_after_day",
+    "convert_to_raw_unicode",
+    # shorten number
+    "Decimal",
+]
+
+
 # Library
 # ---------------------------------------------------------------------------
 import pkgutil
+import subprocess
 from datetime import datetime
+from string import printable
 
-from absfuyu.core import deprecated, versionadded, versionchanged
+from absfuyu.core.docstring import deprecated, versionadded, versionchanged
+from absfuyu.util.shorten_number import Decimal
 
 
 # Function
@@ -137,14 +155,23 @@ def set_min_max(
     >>> set_min_max(808)
     100
     """
-    current_value = set_min(current_value, min_value=min_value)
-    current_value = set_max(current_value, max_value=max_value)
+    # Set min
+    # current_value = set_min(current_value, min_value=min_value)
+    current_value = max(current_value, min_value)
+    # Set max
+    # current_value = set_max(current_value, max_value=max_value)
+    current_value = min(current_value, max_value)
     return current_value
 
 
+@versionchanged("5.6.0", reason="New `custom_msg` parameter")
 @versionadded("3.2.0")
 def stop_after_day(
-    year: int | None = None, month: int | None = None, day: int | None = None
+    year: int | None = None,
+    month: int | None = None,
+    day: int | None = None,
+    *,
+    custom_msg: str | None = None,
 ) -> None:
     """
     Stop working after specified day.
@@ -163,6 +190,10 @@ def stop_after_day(
     day : int
         Desired day
         (Default: ``None`` - 1 day trial)
+
+    custom_msg : str
+        Custom exit message
+        (Default: ``None``)
     """
     # None checking - By default: 1 day trial
     now = datetime.now()
@@ -177,4 +208,81 @@ def stop_after_day(
     end_date = datetime(year, month, day)
     result = end_date - now
     if result.days < 0:
+        if custom_msg:
+            raise SystemExit(custom_msg)
         raise SystemExit("End of time")
+
+
+@versionadded("5.4.0")
+def convert_to_raw_unicode(text: str, partial: bool = True) -> str:
+    r"""
+    Convert text to raw unicode variant.
+
+    Parameters
+    ----------
+    text : str
+        Text to convert
+
+    partial : bool, optional
+        Only convert characters that not in ``string.printable``,
+        by default ``True``
+
+    Returns
+    -------
+    str
+        Converted text.
+
+
+    Example:
+    --------
+    >>> convert_to_raw_unicode("résumé")
+    r\u00E9sum\u00E9
+
+    >>> convert_to_raw_unicode("résumé", partial=False)
+    \u0072\u00E9\u0073\u0075\u006D\u00E9
+    """
+
+    character_set = printable
+
+    def _convert(character: str) -> str:
+        """Get unicode value"""
+        # ord(c): Returns the Unicode code point for a one-character string c.
+        _ord = ord(character)
+        # f"\\u{_ord:04X}": Formats the Unicode code point as a four-digit
+        # hexadecimal number for code points less than 0x10000.
+        # f"\\U{_ord:08X}": Formats the Unicode code point as an eight-digit
+        # hexadecimal number for code points greater than or equal to 0x10000.
+        return f"\\u{_ord:04X}" if _ord < 0x10000 else f"\\U{_ord:08X}"
+
+    return "".join(
+        character if character in character_set and partial else _convert(character)
+        for character in text
+    )
+
+
+@versionadded("5.9.0")
+def is_command_available(cmd: list[str] | str, err_msg: str = "") -> None:
+    """
+    Checks if the desired command available
+
+    Parameters
+    ----------
+    cmd : list[str] | str
+        Command to check
+
+    err_msg : str, optional
+        Custom error message, by default ""
+
+    Raises
+    ------
+    ValueError
+        When command is unvailable
+    """
+    try:
+        subprocess.run(
+            cmd,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    except Exception:
+        raise ValueError(err_msg)

absfuyu/util/api.py

@@ -3,8 +3,8 @@ Absufyu: API
 ------------
 Fetch data stuff
 
-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
@@ -23,18 +23,29 @@ import subprocess
 from pathlib import Path
 from typing import NamedTuple
 
-import requests
-
-from absfuyu.core import versionadded, versionchanged
+from absfuyu.core.baseclass import BaseClass
+from absfuyu.core.docstring import versionadded, versionchanged
 from absfuyu.logger import logger
 
+try:
+    import requests
+except ImportError:
+    raise ImportError("Please install requests package")
+
 
 # Function
 # ---------------------------------------------------------------------------
 class PingResult(NamedTuple):
     """
-    :param host: Host name/IP
-    :param result: Ping result in ms
+    Ping result
+
+    Parameters
+    ----------
+    host : str
+        Host name/IP
+
+    result : str
+        Ping result in ms
     """
 
     host: str
@@ -90,28 +101,40 @@ def ping_windows(host: list[str], ping_count: int = 3) -> list[PingResult]:
 
 # Class
 # ---------------------------------------------------------------------------
-class APIRequest:
-    """API data with cache feature"""
+class APIRequest(BaseClass):
+    """
+    API data with cache feature
+
+    Parameters
+    ----------
+    api_url : str
+        API link
+
+    encoding : str | None, optional
+        Data encoding, by default ``"utf-8"``
+    """
 
     def __init__(
         self,
         api_url: str,
-        *,  # Use "*" to force using keyword in function parameter | Example: APIRequest(url, encoding="utf-8")
+        *,
         encoding: str | None = "utf-8",
     ) -> None:
         """
-        :param api_url: api link
-        :param encoding: data encoding (Default: utf-8)
+        Create APIRequest instance
+
+        Parameters
+        ----------
+        api_url : str
+            API link
+
+        encoding : str | None, optional
+            Data encoding, by default ``"utf-8"``
         """
+
         self.url = api_url
         self.encoding = encoding
 
-    def __str__(self) -> str:
-        return f"{self.__class__.__name__}({self.url})"
-
-    def __repr__(self) -> str:
-        return self.__str__()
-
     def fetch_data(self, *, update: bool = False, json_cache: str | Path):
         """
         Fetch data from an API then cache it for later use

absfuyu/util/cli.py

@@ -0,0 +1,119 @@
+"""
+Absfuyu: CLI
+------------
+Custom Argument Parser
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["FuyuArgumentParser"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+import logging
+import sys
+from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
+from collections.abc import Callable
+from typing import Any
+
+
+# Class
+# ---------------------------------------------------------------------------
+class FuyuArgumentParser(ArgumentParser):
+    """
+    Usage:
+    ------
+    >>> import sys
+    >>> args = FuyuArgumentParser()
+    >>> args.start()
+    """
+
+    def __init__(
+        self,
+        prog: str | None = None,
+        description: str | None = None,
+        epilog: str | None = None,
+        version: str = "0.0.1",
+        formatter_class: Any = ArgumentDefaultsHelpFormatter,
+        prefix_chars: str = "-",
+        argument_default: Any = None,
+        conflict_handler: str = "error",
+        add_help: bool = True,
+        allow_abbrev: bool = True,
+        exit_on_error: bool = True,
+    ) -> None:
+        # Desc
+        if description is None:
+            description = f"Absfuyu CLI {version}"
+
+        # Default
+        self._default_args = ["--help"]
+
+        # Super
+        super().__init__(
+            prog=prog,
+            description=description,
+            epilog=epilog,
+            formatter_class=formatter_class,
+            prefix_chars=prefix_chars,
+            argument_default=argument_default,
+            conflict_handler=conflict_handler,
+            add_help=add_help,
+            allow_abbrev=allow_abbrev,
+            exit_on_error=exit_on_error,
+        )
+
+        # Add version
+        self.add_argument("-v", "--version", action="version", version=f"%(prog)s {version}")
+
+        # Add log level
+        _ll_val = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        self.add_argument(
+            "-ll",
+            "--log-level",
+            metavar="LOG_LEVEL",
+            dest="log_level",
+            choices=_ll_val,
+            default="ERROR",
+            help=f"Log level: {', '.join(_ll_val)}",
+        )
+
+    def _fuyu_set_log_level(self, log_level: str = "ERROR") -> None:
+        log_levels = {
+            "DEBUG": logging.DEBUG,
+            "INFO": logging.INFO,
+            "WARNING": logging.WARNING,
+            "ERROR": logging.ERROR,
+            "CRITICAL": logging.CRITICAL,
+        }
+        logging.basicConfig(
+            level=log_levels[log_level],
+            format="[%(asctime)s] [%(module)s] [%(name)s] [%(funcName)s] [%(levelname)-s] %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+
+    def start(self, default: Callable[[], Any] | None = None):
+        """
+        Quick start for argument parser
+
+        Parameters
+        ----------
+        default : Callable[[], Any] | None, optional
+            | Default callable to run, by default ``None``
+            | Shows help on default behavior (default=None)
+
+        Returns
+        -------
+        Namespace
+            Namespace
+        """
+        if default is None:
+            args = self.parse_args(args=None if sys.argv[1:] else self._default_args)
+        else:
+            args = self.parse_args(args=None if sys.argv[1:] else default())
+        self._fuyu_set_log_level(getattr(args, "log_level", "ERROR"))
+        return args

absfuyu/util/gui.py

@@ -0,0 +1,91 @@
+"""
+Absfuyu: GUI
+------------
+Custom tkinter GUI
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["CustomTkinterApp"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+import tkinter as tk
+
+from absfuyu.pkg_data.logo import AbsfuyuLogo
+
+
+# Class
+# ---------------------------------------------------------------------------
+class CustomTkinterApp(tk.Tk):
+
+    def __init__(self, title: str | None = None, size: tuple[int, int] | None = None) -> None:
+        """
+        Custom Tkinter GUI
+
+        Parameters
+        ----------
+        title : str | None, optional
+            Title of the app, by default None
+
+        size : tuple[int, int] | None, optional
+            Size of the app (width, height), by default None
+        """
+        super().__init__()
+
+        # Set custom icon
+        self.iconphoto(True, tk.PhotoImage(data=AbsfuyuLogo.SHORT))
+
+        # Title
+        self.title(title)
+
+        # Set size
+        self._absfuyu_set_width_height(size)
+
+    # @versionadded("5.10.0")
+    def _absfuyu_set_width_height(self, size: tuple[int, int] | None = None) -> None:
+        """
+        Set width and height for the app.
+
+        Parameters
+        ----------
+        size : tuple[int, int] | None, optional
+            Size of the app (width, height), by default ``None``
+            (420 x 250)
+        """
+        # Set GUI appears in center
+        if size is None:
+            _width = 420
+            _height = 250
+        else:
+            _width, _height = size
+
+        _width_screen = self.winfo_screenwidth()
+        _width_screen_offset = 0.0052  # x offset mutiplier
+        _x_offset = int(_width_screen * _width_screen_offset)
+
+        _height_screen = self.winfo_screenheight()
+        _height_screen_offset = 0.0926  # y offset mutiplier
+        _y_offset = int(_height_screen * _height_screen_offset)
+
+        if _width > _width_screen:
+            _width = int(_width_screen * (1 - 0.001))
+            # _x_offset = 0
+
+        if _height > (_height_screen - _y_offset):
+            _height = int(_height_screen * (1 - 0.001))
+            _y_offset = 0
+
+        _x = (_width_screen / 2) - (_width / 2) - _x_offset
+        _y = (_height_screen / 2) - (_height / 2) - _y_offset
+
+        self.geometry(f"{_width}x{_height}+{int(_x)}+{int(_y)}")
+
+
+if __name__ == "__main__":
+    app = CustomTkinterApp("absfuyu")
+    app.mainloop()