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

absfuyu/core/dummy_cli.py

@@ -0,0 +1,67 @@
+"""
+Absfuyu: Core
+-------------
+Dummy cli
+
+Version: 5.0.0
+Date updated: 25/02/2025 (dd/mm/yyyy)
+"""
+
+# Module Package
+# ---------------------------------------------------------------------------
+__all__ = ["cli"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+import sys
+from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
+
+from absfuyu import __title__, __version__
+
+
+# Function
+# ---------------------------------------------------------------------------
+def get_parser(
+    name: str | None = None,
+    description: str | None = None,
+    epilog: str | None = None,
+    *,
+    version: str = "",
+    add_help: bool = True,
+    add_logging: bool = True,
+) -> ArgumentParser:
+    arg_parser = ArgumentParser(
+        prog=name,
+        description=description,
+        epilog=epilog,
+        add_help=add_help,
+        formatter_class=ArgumentDefaultsHelpFormatter,
+        # allow_abbrev=False, # Disable long options recognize
+        # exit_on_error=True
+    )
+    arg_parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {version}"
+    )
+    if add_logging:
+        _ll_val = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        arg_parser.add_argument(
+            "--log-level",
+            metavar="LOG_LEVEL",
+            dest="log_level",
+            choices=_ll_val,
+            default="INFO",
+            help=f"Log level: {_ll_val}",
+        )
+    return arg_parser
+
+
+def cli() -> None:
+    desc = "This is a dummy cli, please install <click> and <colorama> package to use this feature"
+    arg_parser = get_parser(
+        name=__title__,
+        description=desc,
+        version=__version__,
+        add_logging=False,
+    )
+    args = arg_parser.parse_args(args=None if sys.argv[1:] else ["--help"])  # noqa

absfuyu/core/dummy_func.py

@@ -0,0 +1,47 @@
+"""
+Absfuyu: Core
+-------------
+Dummy functions when other libraries are unvailable
+
+Version: 5.0.0
+Date updated: 14/02/2025 (dd/mm/yyyy)
+"""
+
+# Module Package
+# ---------------------------------------------------------------------------
+__all__ = [
+    "tqdm",
+    "unidecode",
+]
+
+
+# Library
+# ---------------------------------------------------------------------------
+from importlib import import_module
+
+# Wrapper
+# ---------------------------------------------------------------------------
+# tqdm wrapper
+try:
+    tqdm = import_module("tqdm").tqdm
+except ModuleNotFoundError:
+
+    def tqdm(iterable, *args, **kwargs):
+        """
+        Dummy tqdm function,
+        install package ``tqdm`` to fully use this feature
+        """
+        return iterable
+
+
+# unidecode wrapper
+try:
+    unidecode = import_module("unidecode").unidecode
+except ModuleNotFoundError:
+
+    def unidecode(*args, **kwargs):
+        """
+        Dummy unidecode function,
+        install package ``unidecode`` to fully use this feature
+        """
+        return args[0]

absfuyu/dxt/__init__.py

@@ -0,0 +1,42 @@
+"""
+Absfuyu: Data Extension
+-----------------------
+Extension for data type such as ``list``, ``str``, ``dict``, ...
+
+Version: 5.0.0
+Date updated: 11/01/2025 (dd/mm/yyyy)
+
+Features:
+---------
+- DictExt
+- IntExt
+- ListExt
+- Text
+"""
+
+# Module Package
+# ---------------------------------------------------------------------------
+__all__ = [
+    # Main
+    "DictExt",
+    "IntExt",
+    "ListExt",
+    "Text",
+    # Support
+    "DictAnalyzeResult",
+    "DictBoolFalse",
+    "DictBoolTrue",
+    "ListNoDunder",
+    "ListREPR",
+    "Pow",
+    "TextAnalyzeDictFormat",
+]
+
+
+# Library
+# ---------------------------------------------------------------------------
+from absfuyu.dxt.dictext import DictAnalyzeResult, DictExt
+from absfuyu.dxt.dxt_support import DictBoolFalse, DictBoolTrue, ListNoDunder, ListREPR
+from absfuyu.dxt.intext import IntExt, Pow
+from absfuyu.dxt.listext import ListExt
+from absfuyu.dxt.strext import Text, TextAnalyzeDictFormat

absfuyu/dxt/dictext.py

@@ -0,0 +1,201 @@
+"""
+Absfuyu: Data Extension
+-----------------------
+dict extension
+
+Version: 5.0.0
+Date updated: 14/02/2025 (dd/mm/yyyy)
+"""
+
+# Module Package
+# ---------------------------------------------------------------------------
+__all__ = ["DictExt", "DictAnalyzeResult"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+import operator
+from collections.abc import Callable
+from typing import Any, NamedTuple, Self
+
+from absfuyu.core import ShowAllMethodsMixin, versionadded, versionchanged
+
+
+# Class
+# ---------------------------------------------------------------------------
+class DictAnalyzeResult(NamedTuple):
+    """
+    Result for ``DictExt.analyze()``
+    """
+
+    max_value: int | float
+    min_value: int | float
+    max_list: list
+    min_list: list
+
+
+class DictExt(ShowAllMethodsMixin, dict):
+    """
+    ``dict`` extension
+    """
+
+    @versionchanged("3.3.0", reason="Updated return type")
+    def analyze(self) -> DictAnalyzeResult:
+        """
+        Analyze all the key values (``int``, ``float``)
+        in ``dict`` then return highest/lowest index
+
+        Returns
+        -------
+        dict
+            Analyzed data
+
+
+        Example:
+        --------
+        >>> test = DictExt({
+        ...     "abc": 9,
+        ...     "def": 9,
+        ...     "ghi": 8,
+        ...     "jkl": 1,
+        ...     "mno": 1
+        ... })
+        >>> test.analyze()
+        DictAnalyzeResult(max_value=9, min_value=1, max_list=[('abc', 9), ('def', 9)], min_list=[('jkl', 1), ('mno', 1)])
+        """
+        try:
+            dct: dict = self.copy()
+
+            max_val: int | float = max(list(dct.values()))
+            min_val: int | float = min(list(dct.values()))
+            max_list = []
+            min_list = []
+
+            for k, v in dct.items():
+                if v == max_val:
+                    max_list.append((k, v))
+                if v == min_val:
+                    min_list.append((k, v))
+
+            return DictAnalyzeResult(max_val, min_val, max_list, min_list)
+
+        except TypeError:
+            err_msg = "Value must be int or float"
+            # logger.error(err_msg)
+            raise ValueError(err_msg)  # noqa: B904
+
+    def swap_items(self) -> Self:
+        """
+        Swap ``dict.keys()`` with ``dict.values()``
+
+        Returns
+        -------
+        DictExt
+            Swapped dict
+
+
+        Example:
+        --------
+        >>> test = DictExt({"abc": 9})
+        >>> test.swap_items()
+        {9: 'abc'}
+        """
+        # return self.__class__(zip(self.values(), self.keys()))
+        return self.__class__({v: k for k, v in self.items()})
+
+    def apply(self, func: Callable, apply_to_value: bool = True) -> Self:
+        """
+        Apply function to ``DictExt.keys()`` or ``DictExt.values()``
+
+        Parameters
+        ----------
+        func : Callable
+            Callable function
+
+        apply_to_value : bool
+            | ``True``: Apply ``func`` to ``DictExt.values()``
+            | ``False``: Apply ``func`` to ``DictExt.keys()``
+
+        Returns
+        -------
+        DictExt
+            DictExt
+
+
+        Example:
+        --------
+        >>> test = DictExt({"abc": 9})
+        >>> test.apply(str)
+        {'abc': '9'}
+        """
+        if apply_to_value:
+            new_dict = {k: func(v) for k, v in self.items()}
+        else:
+            new_dict = {func(k): v for k, v in self.items()}
+        return self.__class__(new_dict)
+
+    @versionchanged("5.0.0", reason="Updated to handle more types and operator")
+    @versionadded("3.4.0")
+    def aggregate(
+        self,
+        other_dict: dict,
+        default_value: Any = 0,
+        operator_func: Callable[[Any, Any], Any] = operator.add,  # operator add
+    ) -> Self:
+        """
+        Aggregates the values of the current dictionary with another dictionary.
+
+        For each unique key, this method applies the specified operator to the values
+        from both dictionaries. If a key exists in only one dictionary, its value is used.
+        If an error occurs during aggregation (e.g., incompatible types), the values
+        from both dictionaries are returned as a list.
+
+        Parameters
+        ----------
+        other_dict : dict
+            The dictionary to aggregate with.
+
+        default_value : Any, optional
+            The value to use for missing keys, by default ``0``
+
+
+        operator_func : Callable[[Any, Any], Any], optional
+            A function that takes two arguments and returns a single value,
+            by default ``operator.add``
+
+        Returns
+        -------
+        Self
+            A new instance of the aggregated dictionary.
+
+
+        Example:
+        --------
+        >>> test = DictExt({"test": 5, "test2": 9})
+        >>> agg = {"test1": 10, "test2": 1}
+        >>> print(test.aggregate(agg))
+        {'test1': 10, 'test': 5, 'test2': 10}
+
+        >>> test = DictExt({"test": 5, "test2": 9})
+        >>> agg = {"test1": 10, "test2": "1"}
+        >>> print(test.aggregate(agg))
+        {'test1': 10, 'test': 5, 'test2': [9, '1']}
+        """
+        merged_output = {}
+
+        # Create a set of all unique keys from both dictionaries
+        all_keys = set(self) | set(other_dict)
+
+        for k in all_keys:
+            # Retrieve values with default fallback
+            value_self = self.get(k, default_value)
+            value_other = other_dict.get(k, default_value)
+
+            try:
+                # Attempt to apply the operator for existing keys
+                merged_output[k] = operator_func(value_self, value_other)
+            except TypeError:
+                # If a TypeError occurs (e.g., if values are not compatible), store values as a list
+                merged_output[k] = [value_self, value_other]
+
+        return self.__class__(merged_output)

absfuyu/dxt/dxt_support.py

@@ -0,0 +1,79 @@
+"""
+Absfuyu: Data Extension
+-----------------------
+Support classes
+
+Version: 5.0.0
+Date updated: 11/02/2025 (dd/mm/yyyy)
+"""
+
+# Module Package
+# ---------------------------------------------------------------------------
+__all__ = ["DictBoolTrue", "DictBoolFalse"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+from typing import Any
+
+from absfuyu.logger import _compress_list_for_print
+
+
+# Dict Boolean Masking Repr
+# ---------------------------------------------------------------------------
+def _dict_bool(dict_object: dict, option: bool) -> dict | None:
+    """
+    Support function DictBool class
+    """
+    out = dict()
+    for k, v in dict_object.items():
+        if v == option:
+            out[k] = v
+    if out:
+        return out
+    else:
+        return None
+
+
+class DictBoolTrue(dict[Any, bool]):
+    """Only show items when ``values == True`` in ``__repr__()``"""
+
+    def __repr__(self) -> str:
+        temp = self.copy()
+        return _dict_bool(temp, True).__repr__()
+
+
+class DictBoolFalse(dict[Any, bool]):
+    """Only show items when ``values == False`` in ``__repr__()``"""
+
+    def __repr__(self) -> str:
+        temp = self.copy()
+        return _dict_bool(temp, False).__repr__()
+
+
+# ---------------------------------------------------------------------------
+class ListREPR(list):
+    """Show ``list`` in shorter form"""
+
+    def __repr__(self) -> str:
+        return _compress_list_for_print(self, 9)
+
+
+class ListNoDunder(list[str]):
+    """Use with ``object.__dir__()``"""
+
+    def __repr__(self) -> str:
+        out = [x for x in self if not x.startswith("__")]
+        return out.__repr__()
+
+
+# class DictNoDunder(dict):  # W.I.P
+#     """Remove dunder methods in ``__repr__()`` of dict"""
+
+#     def __repr__(self) -> str:
+#             temp = self.copy()
+#             out = dict()
+#             for k, v in temp.items():
+#                 if not str(k).startswith("__"):
+#                     out.__setattr__(k, v)
+#             return out.__repr__()