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

absfuyu/dxt/listext.py

@@ -3,10 +3,12 @@ Absfuyu: Data Extension
 -----------------------
 list extension
 
-Version: 5.6.1
-Date updated: 12/09/2025 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
 
+from __future__ import annotations
+
 # Module Package
 # ---------------------------------------------------------------------------
 __all__ = ["ListExt"]
@@ -20,13 +22,16 @@ from collections import Counter
 from collections.abc import Callable, Iterable
 from heapq import heapreplace
 from itertools import accumulate, chain, count, groupby, zip_longest
-from typing import Any, Literal, Self, cast, overload
+from typing import Any, Literal, Self, TypeVar, cast, overload
 
 from absfuyu.core.baseclass import GetClassMembersMixin
 from absfuyu.core.docstring import deprecated, versionadded, versionchanged
-from absfuyu.typings import T as _T
 from absfuyu.util import set_min_max
 
+# Type
+# ---------------------------------------------------------------------------
+T = TypeVar("T")
+R = TypeVar("R")  # Return type - Can be anything
 
 # Class
 # ---------------------------------------------------------------------------
@@ -80,9 +85,7 @@ class ListExt(GetClassMembersMixin, list):
         >>> ListExt(range(10)).head(2)
         [0, 1]
         """
-        number_of_items = int(
-            set_min_max(number_of_items, min_value=0, max_value=len(self))
-        )
+        number_of_items = int(set_min_max(number_of_items, min_value=0, max_value=len(self)))
         return self[:number_of_items]
 
     def tail(self, number_of_items: int = 5) -> list:
@@ -106,9 +109,7 @@ class ListExt(GetClassMembersMixin, list):
         >>> ListExt(range(10)).tail(2)
         [8, 9]
         """
-        number_of_items = int(
-            set_min_max(number_of_items, min_value=0, max_value=len(self))
-        )
+        number_of_items = int(set_min_max(number_of_items, min_value=0, max_value=len(self)))
         return self[::-1][:number_of_items][::-1]
 
     # Misc
@@ -165,15 +166,13 @@ class ListExt(GetClassMembersMixin, list):
                 type_weights[type(x)] = len(type_weights)
         # logger.debug(f"Type weight: {type_weights}")
 
-        output = sorted(
-            lst, key=lambda x: (type_weights[type(x)], str(x)), reverse=reverse
-        )
+        output = sorted(lst, key=lambda x: (type_weights[type(x)], str(x)), reverse=reverse)
 
         # logger.debug(output)
         return self.__class__(output)
 
     @overload
-    def freq(self) -> dict: ...
+    def freq(self) -> dict: ...  # type: ignore
 
     @overload
     def freq(
@@ -256,9 +255,7 @@ class ListExt(GetClassMembersMixin, list):
         # logger.debug(times_appear)
 
         if appear_increment:
-            times_appear_increment: list[int] = list(
-                accumulate(times_appear.values(), operator.add)
-            )
+            times_appear_increment: list[int] = list(accumulate(times_appear.values(), operator.add))
             # logger.debug(times_appear_increment)
             return times_appear_increment  # incremental index list
         else:
@@ -385,7 +382,7 @@ class ListExt(GetClassMembersMixin, list):
         return self.__class__(zip(nums, self))
 
     @versionadded("5.3.0")  # no test case yet
-    def transpose(self, fillvalue: _T | None = None, /) -> Self:
+    def transpose(self, fillvalue: Any | None = None, /) -> Self:
         """
         Transpose a list of iterable.
 
@@ -459,6 +456,11 @@ class ListExt(GetClassMembersMixin, list):
         """
         return [self.pick_one() for _ in range(number_of_items)]
 
+    @versionadded("5.10.0")
+    def shuffle(self) -> Self:
+        random.shuffle(self)
+        return self
+
     # Len
     @versionchanged("5.2.0", reason="Handle more type")
     def len_items(self) -> Self:
@@ -746,7 +748,7 @@ class ListExt(GetClassMembersMixin, list):
         return self.slice_points(slice_points)
 
     @versionadded("5.3.0")  # no test case yet
-    def to_column(self, ncols: int, fillvalue: _T | None = None) -> Self:
+    def to_column(self, ncols: int, fillvalue: Any | None = None) -> Self:
         """
         Smart convert 1 dimension list to 2 dimension list,
         in which, number of columns = ``ncols``.
@@ -756,7 +758,7 @@ class ListExt(GetClassMembersMixin, list):
         ncols : int
             Number of columns
 
-        fillvalue : T | None, optional
+        fillvalue : Any | None, optional
             Fill value, by default ``None``
 
         Returns
@@ -857,9 +859,7 @@ class ListExt(GetClassMembersMixin, list):
             fill = " "
 
         # Calculate how many columns of text
-        column_count = (
-            max(1, available_width // max_item_length) if max_item_length > 0 else 1
-        )
+        column_count = max(1, available_width // max_item_length) if max_item_length > 0 else 1
 
         # splitted_chunk: list[list[str]] = self.split_chunk(cols)
         # mod_chunk = self.__class__(
@@ -876,3 +876,475 @@ class ListExt(GetClassMembersMixin, list):
             mod_chunk = self.split_chunk(column_count).apply(mod_item)
 
         return mod_chunk
+
+
+class ListExt2(GetClassMembersMixin, list[T]):
+    """
+    ``list`` extension (with generic - W.I.P)
+
+    >>> # For a list of new methods
+    >>> ListExt2.show_all_methods()
+    """
+
+    # MARK: Info
+    def head(self, number_of_items: int = 5, /) -> list[T]:
+        """
+        Show first ``number_of_items`` items in ``ListExt``
+
+        Parameters
+        ----------
+        number_of_items : int
+            | Number of items to shows at once
+            | (Default: ``5``)
+
+        Returns
+        -------
+        list
+            Filtered list
+
+
+        Example:
+        --------
+        >>> ListExt(range(10)).head(2)
+        [0, 1]
+        """
+        number_of_items = int(set_min_max(number_of_items, min_value=0, max_value=len(self)))
+        return self[:number_of_items]
+
+    def tail(self, number_of_items: int = 5, /) -> list[T]:
+        """
+        Show last ``number_of_items`` items in ``ListExt``
+
+        Parameters
+        ----------
+        number_of_items : int
+            | Number of items to shows at once
+            | (Default: ``5``)
+
+        Returns
+        -------
+        list
+            Filtered list
+
+
+        Example:
+        --------
+        >>> ListExt(range(10)).tail(2)
+        [8, 9]
+        """
+        number_of_items = int(set_min_max(number_of_items, min_value=0, max_value=len(self)))
+        return self[::-1][:number_of_items][::-1]
+
+    # MARK: Misc
+    def apply(self, func: Callable[[T], R]) -> ListExt2[R]:
+        """
+        Apply function to each entry
+
+        Parameters
+        ----------
+        func : Callable[[Any], Any]
+            Callable function
+
+        Returns
+        -------
+        Self
+            ListExt
+
+
+        Example:
+        --------
+        >>> test = ListExt([1, 2, 3])
+        >>> test.apply(str)
+        ['1', '2', '3']
+        """
+        # return self.__class__(map(func, self))
+        return self.__class__(func(x) for x in self)  # type: ignore
+
+    def sorts(self, reverse: bool = False) -> Self:
+        """
+        Sort all items (with different type) in ``list``
+
+        Parameters
+        ----------
+        reverse : bool
+            - ``True`` then sort in descending order
+            - ``False`` then sort in ascending order (default value)
+
+        Returns
+        -------
+        Self
+            A sorted list
+
+
+        Example:
+        --------
+        >>> test = ListExt([9, "abc", 3.5, "aaa", 1, 1.4])
+        >>> test.sorts()
+        [1, 9, 'aaa', 'abc', 1.4, 3.5]
+        """
+        lst = self.copy()
+        type_weights: dict = {}
+        for x in lst:
+            if type(x) not in type_weights:
+                type_weights[type(x)] = len(type_weights)
+        # logger.debug(f"Type weight: {type_weights}")
+
+        output = sorted(lst, key=lambda x: (type_weights[type(x)], str(x)), reverse=reverse)
+
+        # logger.debug(output)
+        return self.__class__(output)
+
+    @versionchanged("5.2.0", reason="New ``recursive`` parameter")
+    def flatten(self, recursive: bool = False) -> Self:
+        """
+        Flatten the list
+
+        Parameters
+        ----------
+        recursive : bool
+            Recursively flatten the list, by default ``False``
+
+        Returns
+        -------
+        Self
+            Flattened list
+
+
+        Example:
+        --------
+        >>> test = ListExt([["test"], ["test", "test"], ["test"]])
+        >>> test.flatten()
+        ['test', 'test', 'test', 'test']
+        """
+
+        def instance_checking(item):
+            if isinstance(item, str):
+                return [item]
+            if isinstance(item, Iterable):
+                return item
+            return [item]
+
+        # Flatten
+        list_of_list = (instance_checking(x) for x in self)
+        flattened = self.__class__(chain(*list_of_list))
+
+        # Recursive
+        if recursive:
+
+            def _condition(item) -> bool:
+                if isinstance(item, str):
+                    return False
+                return isinstance(item, Iterable)
+
+            while any(flattened.apply(_condition)):
+                flattened = flattened.flatten()
+
+        # Return
+        return flattened
+
+    @versionadded("5.2.0")
+    def join(self, sep: str = " ", /) -> str:
+        """
+        Join every element in list to str (``str.join()`` wrapper).
+
+        Parameters
+        ----------
+        sep : str, optional
+            Separator between each element, by default ``" "``
+
+        Returns
+        -------
+        str
+            Joined list
+
+
+        Example:
+        --------
+        >>> ListExt(["a", "b", "c"]).join()
+        a b c
+
+        >>> # Also work with non-str type
+        >>> ListExt([1, 2, 3]).join()
+        1 2 3
+        """
+        try:
+            return sep.join(self)  # type: ignore
+        except TypeError:
+            return sep.join(self.apply(str))
+
+    def group_by_pair_value(self, max_loop: int = 3):
+        """
+        Assume each ``list`` in ``list`` is a pair value,
+        returns a ``list`` contain all paired value
+
+        Parameters
+        ----------
+        max_loop : int
+            Times to run functions (minimum: ``3``)
+
+        Returns
+        -------
+        list[list]
+            Grouped value
+
+
+        Example:
+        --------
+        >>> test = ListExt([[1, 2], [2, 3], [4, 3], [5, 6]])
+        >>> test.group_by_pair_value()
+        [[1, 2, 3, 4], [5, 6]]
+
+        >>> test = ListExt([[8, 3], [4, 6], [6, 3], [5, 2], [7, 2]])
+        >>> test.group_by_pair_value()
+        [[8, 3, 4, 6], [2, 5, 7]]
+
+        >>> test = ListExt([["a", 4], ["b", 4], [5, "c"]])
+        >>> test.group_by_pair_value()
+        [['a', 4, 'b'], ['c', 5]]
+        """
+
+        iter = self.copy()
+
+        # Init loop
+        for _ in range(max(max_loop, 3)):
+            temp: dict[Any, list] = {}
+            # Make dict{key: all `item` that contains `key`}
+            for item in iter:
+                for x in item:
+                    if temp.get(x, None) is None:
+                        temp[x] = [item]
+                    else:
+                        temp[x].append(item)
+
+            # Flatten dict.values
+            temp = {k: list(set(chain(*v))) for k, v in temp.items()}
+
+            iter = list(temp.values())
+
+        return list(x for x, _ in groupby(iter))
+
+    def split_equal(self, n: int, sort: bool = True) -> ListExt2[list[T]]:
+        """
+        Try to equally split a list of number into ``n`` equal sum parts.
+
+        **Note:** Element in list must be a number.
+
+        Parameters
+        ----------
+        n : int
+            Split into how many parts. Must be >= 1.
+
+        sort : bool, optional
+            Sort the instance before split, by default ``True``
+
+        Returns
+        -------
+        Self
+            Splitted (list[list])
+
+
+        Example:
+        --------
+        >>> ListExt(range(1, 11)).split_equal(2)
+        [[10, 7, 5, 4, 1], [9, 8, 6, 3, 2]]
+        """
+
+        # https://stackoverflow.com/a/61649667
+        bins: list[list[int]] = [[0] for _ in range(max(n, 1))]
+        if sort:
+            # self = self.sorts(reverse=True)
+            self = self.__class__(sorted(self, reverse=True))
+        for x in self:
+            least = bins[0]
+            least[0] += x
+            least.append(x)
+            heapreplace(bins, least)
+        return self.__class__(x[1:] for x in bins)
+
+    # MARK: Random
+    def pick_one(self) -> T:
+        """
+        Pick one random items from ``list``
+
+        Returns
+        -------
+        Any
+            Random value
+
+
+        Example:
+        --------
+        >>> test = ListExt(["foo", "bar"])
+        >>> test.pick_one()
+        'bar'
+        """
+        if len(self) != 0:
+            out = random.choice(self)
+            # logger.debug(out)
+            return out
+        else:
+            # logger.debug("List empty!")
+            raise IndexError("List empty!")
+
+    def get_random(self, number_of_items: int = 5, /) -> list[T]:
+        """
+        Get ``number_of_items`` random items in ``ListExt``
+
+        Parameters
+        ----------
+        number_of_items : int
+            Number random of items, by default ``5``
+
+        Returns
+        -------
+        list
+            Filtered list
+        """
+        return [self.pick_one() for _ in range(number_of_items)]
+
+    @versionadded("5.10.0")
+    def shuffle(self) -> Self:
+        """
+        Shuffle the list itself
+
+        Returns
+        -------
+        Self
+            Shuffled list
+        """
+        random.shuffle(self)
+        return self
+
+    # MARK: Len
+    @versionchanged("5.2.0", reason="Handle more type")
+    def len_items(self) -> ListExt2[int]:
+        """
+        ``len()`` for every item in ``self``
+
+        Returns
+        -------
+        Self
+            List of ``len()``'ed value
+
+
+        Example:
+        --------
+        >>> test = ListExt(["foo", "bar", "pizza"])
+        >>> test.len_items()
+        [3, 3, 5]
+        """
+
+        def _len(item: Any) -> int:
+            try:
+                return len(item)
+            except TypeError:
+                return len(str(item))
+
+        return self.__class__([_len(x) for x in self])  # type: ignore
+
+    @versionchanged("5.2.0", reason="New ``recursive`` parameter")
+    def mean_len(self, recursive: bool = False) -> float:
+        """
+        Average length of every item. Returns zero if failed (empty list, ZeroDivisionError).
+
+        Parameters
+        ----------
+        recursive : bool
+            Recursively find the average length of items in nested lists, by default ``False``
+
+        Returns
+        -------
+        float
+            Average length
+
+
+        Example:
+        --------
+        >>> test = ListExt(["foo", "bar", "pizza"])
+        >>> test.mean_len()
+        3.6666666666666665
+        """
+
+        if recursive:
+            dat = self.flatten(recursive=recursive)
+        else:
+            dat = self
+
+        try:
+            return sum(dat.len_items()) / len(dat)
+        except ZeroDivisionError:
+            return 0.0
+
+    @versionadded("5.2.0")
+    def max_item_len(self, recursive: bool = False) -> int:
+        """
+        Find the maximum length of items in the list.
+
+        Parameters
+        ----------
+        recursive : bool
+            Recursively find the maximum length of items in nested lists, by default ``False``
+
+        Returns
+        -------
+        int
+            Maximum length of items
+
+
+        Example:
+        --------
+        >>> test = ListExt(["test", "longer_test"])
+        >>> test.max_item_len()
+        11
+
+        >>> test = ListExt([["short"], ["longer_test"]])
+        >>> test.max_item_len(recursive=True)
+        11
+        """
+        if recursive:
+            return cast(int, max(self.flatten(recursive=True).len_items()))
+        return cast(int, max(self.len_items()))
+
+    # MARK: Group/Unique
+    def unique(self) -> Self:
+        """
+        Remove duplicates
+
+        Returns
+        -------
+        Self
+            Duplicates removed list
+
+
+        Example:
+        --------
+        >>> test = ListExt([1, 1, 1, 2, 2, 3])
+        >>> test.unique()
+        [1, 2, 3]
+        """
+        return self.__class__(set(self))
+
+    def group_by_unique(self) -> ListExt2[list[T]]:
+        """
+        Group duplicated elements into list
+
+        Returns
+        -------
+        Self
+            Grouped value
+
+
+        Example:
+        --------
+        >>> test = ListExt([1, 2, 3, 1, 3, 3, 2])
+        >>> test.group_by_unique()
+        [[1, 1], [2, 2], [3, 3, 3]]
+        """
+        temp = groupby(self.sorts())
+        return self.__class__([list(g) for _, g in temp])
+
+
+if __name__ == "__main__":
+    test = ListExt2([1, 2, 3, 4, 5, "s"])
+    a = test.group_by_unique()
+    print(a, type(a))

absfuyu/dxt/strext.py

@@ -3,8 +3,8 @@ Absfuyu: Data Extension
 -----------------------
 str extension
 
-Version: 5.6.1
-Date updated: 12/09/2025 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
 
 # Module Package

absfuyu/extra/__init__.py

@@ -3,8 +3,8 @@ Absfuyu: Extra
 --------------
 Features that require additional libraries
 
-Version: 5.6.1
-Date updated: 12/09/2025 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
 
 

absfuyu/extra/audio/__init__.py

@@ -0,0 +1,8 @@
+"""
+Absfuyu: Audio
+--------------
+Audio related
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""

absfuyu/extra/audio/_util.py

@@ -0,0 +1,57 @@
+"""
+Absfuyu: Audio
+--------------
+Audio convert, lossless checker
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["StatusCode", "ResultStatus"]
+
+# Library
+# ---------------------------------------------------------------------------
+from enum import StrEnum
+from pathlib import Path
+
+# Class Enum, Result
+# ---------------------------------------------------------------------------
+try:
+    from rich import print
+
+    class StatusCode(StrEnum):
+        OK = "[bold green]OK[/]"
+        SKIP = "[bold yellow]SKIP[/]"
+        ERROR = "[bold red]ERROR[/]"
+        LOSSLESS = "[bold green]LOSSLESS[/]"
+        NOT_LOSSLESS = "[bold red]NOT LOSSLESS[/]"
+        HIRES = "[bold blue]HIRES[/]"
+
+except ImportError:
+
+    class StatusCode(StrEnum):
+        OK = "OK"
+        SKIP = "SKIP"
+        ERROR = "ERROR"
+        LOSSLESS = "LOSSLESS"
+        NOT_LOSSLESS = "NOT LOSSLESS"
+        HIRES = "HIRES"
+
+
+class ResultStatus:
+    """
+    Result status
+    """
+
+    def __init__(self, status: StatusCode, path: Path) -> None:
+        self.status = status
+        self.path = path
+
+    def __repr__(self) -> str:
+        return f"{self.status} : {self.path.name}"
+
+    def print(self) -> None:
+        """Print repr (for rich package)"""
+        print(self.status, ": ", self.path.name)