absfuyu 3.1.1__py3-none-any.whl → 3.3.3__py3-none-any.whl

absfuyu/general/data_extension.py

@@ -3,22 +3,21 @@ Absfuyu: Data extension
 -----------------------
 Extension for data type such as ``list``, ``str``, ``dict``, ...
 
-Version: 1.12.3
-Date updated: 23/01/2024 (dd/mm/yyyy)
+Version: 1.14.3
+Date updated: 05/04/2024 (dd/mm/yyyy)
 
 Features:
 ---------
-- Text
-- ListExt
 - DictExt
 - IntNumber
+- ListExt
+- Text
 
 Usage:
 ------
 >>> from absfuyu.general.data_extension import DictExt, IntNumber, ListExt, Text
 """
 
-
 # Module level
 ###########################################################################
 __all__ = [
@@ -34,21 +33,42 @@ __all__ = [
     "DictBoolTrue",
     "DictBoolFalse",
     # "DictNoDunder",
+    # Dict format
+    "TextAnalyzeDictFormat",
+    # Support
+    "DictAnalyzeResult",
 ]
 
 
 # Library
 ###########################################################################
-from collections import Counter
-from itertools import accumulate, chain, groupby
 import math
 import operator
 import random
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
-from sys import version_info as python_version
-
-from absfuyu.general.generator import Generator, Charset
-from absfuyu.logger import logger, _compress_list_for_print
+from collections import Counter
+from itertools import accumulate, chain, groupby
+from sys import version_info as _python_version
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    NamedTuple,
+    Optional,
+    Tuple,
+    TypedDict,
+    Union,
+)
+
+if _python_version.minor >= 11:
+    from typing import NotRequired
+else:
+    from typing_extensions import NotRequired  # type: ignore
+
+from deprecated.sphinx import versionadded, versionchanged
+
+from absfuyu.general.generator import Charset, Generator
+from absfuyu.logger import _compress_list_for_print, logger
 from absfuyu.util import set_min, set_min_max
 
 
@@ -68,7 +88,7 @@ def _dict_bool(dict_object: dict, option: bool) -> Optional[dict]:
         return None
 
 
-# Sub class
+# MARK: Sub class
 ###########################################################################
 class Pow:
     """Number power by a number"""
@@ -93,7 +113,7 @@ class Pow:
 
         :rtype: list[int | float]
         """
-        return [self.number] * self.power_by
+        return [self.number] * int(self.power_by)
 
     def calculate(self) -> float:
         """
@@ -148,14 +168,59 @@ class DictBoolFalse(Dict[Any, bool]):
 #             return out.__repr__()
 
 
+class TextAnalyzeDictFormat(TypedDict):
+    """
+    Dict format for ``Text.analyze()`` method
+
+    Parameters
+    ----------
+    digit : int
+        Number of digit characters
+
+    uppercase : int
+        Number of uppercase characters
+
+    lowercase : int
+        Number of lowercase characters
+
+    other : int
+        Number of other printable characters
+
+    is_pangram : NotRequired[bool]
+        Is a pangram (Not required)
+
+    is_palindrome : NotRequired[bool]
+        Is a palindrome (Not required)
+    """
+
+    digit: int
+    uppercase: int
+    lowercase: int
+    other: int
+    is_pangram: NotRequired[bool]
+    is_palindrome: NotRequired[bool]
+
+
+class DictAnalyzeResult(NamedTuple):
+    """
+    Result for ``DictExt.analyze()``
+    """
+
+    max_value: Union[int, float]
+    min_value: Union[int, float]
+    max_list: list
+    min_list: list
+
+
 # Class
 ###########################################################################
+# MARK: Text
 class Text(str):
     """
     ``str`` extension
     """
 
-    def divide(self, string_split_size: int = 60) -> list:
+    def divide(self, string_split_size: int = 60) -> List[str]:
         """
         Divide long string into smaller size
 
@@ -167,7 +232,7 @@ class Text(str):
 
         Returns
         -------
-        list
+        list[str]
             A list in which each item is a smaller
             string with the size of ``string_split_size``
             (need to be concaternate later)
@@ -179,7 +244,7 @@ class Text(str):
         >>> test.divide(string_split_size=20)
         ['This is an extremely', ' long line of text!']
         """
-        temp = self
+        temp = str(self)
         output = []
         while len(temp) != 0:
             output.append(temp[:string_split_size])
@@ -243,7 +308,6 @@ class Text(str):
         output = []
 
         # split variable
-        splt_var_len = split_var_len
         splt_len = len(temp)
 
         if custom_var_name is None:
@@ -283,13 +347,20 @@ class Text(str):
 
         return output
 
-    def analyze(self) -> dict:
+    @versionchanged(version="3.3.0", reason="Update functionality")
+    def analyze(self, full: bool = False) -> TextAnalyzeDictFormat:
         """
         String analyze (count number of type of character)
 
+        Parameters
+        ----------
+        full : bool
+            Full analyze when ``True``
+            (Default: ``False``)
+
         Returns
         -------
-        dict
+        dict | TextAnalyzeDictFormat
             A dictionary contains number of digit character,
             uppercase character, lowercase character, and
             special character
@@ -304,7 +375,12 @@ class Text(str):
 
         temp = self
 
-        detail = {"digit": 0, "uppercase": 0, "lowercase": 0, "other": 0}
+        detail: TextAnalyzeDictFormat = {
+            "digit": 0,
+            "uppercase": 0,
+            "lowercase": 0,
+            "other": 0,
+        }
 
         for x in temp:
             if ord(x) in range(48, 58):  # num
@@ -316,6 +392,10 @@ class Text(str):
             else:
                 detail["other"] += 1
 
+        if full:
+            detail["is_palindrome"] = self.is_palindrome()
+            detail["is_pangram"] = self.is_pangram()
+
         return detail
 
     def reverse(self) -> "Text":
@@ -334,7 +414,7 @@ class Text(str):
         >>> test.reverse()
         '!dlroW ,olleH'
         """
-        return __class__(self[::-1])
+        return self.__class__(self[::-1])
 
     def is_pangram(self) -> bool:
         """
@@ -403,7 +483,7 @@ class Text(str):
 
             for i in range(str_len):
                 if i % 2 == 0:
-                    temp.append(f"\\x")
+                    temp.append("\\x")
                 temp.append(hex_str[i])
             return "".join(temp)
         else:
@@ -431,7 +511,7 @@ class Text(str):
         >>> test.random_capslock()
         'tHis iS An ExtREmELY loNg liNE oF tExT!'
         """
-        probability = set_min_max(probability)
+        probability = int(set_min_max(probability))
         text = self.lower()
 
         temp = []
@@ -440,7 +520,7 @@ class Text(str):
                 x = x.upper()
             temp.append(x)
         logger.debug(temp)
-        return __class__("".join(temp))
+        return self.__class__("".join(temp))
 
     def reverse_capslock(self) -> "Text":
         """
@@ -464,12 +544,12 @@ class Text(str):
                 temp[i] = x.lower()
             else:
                 temp[i] = x.upper()
-        return __class__("".join(temp))
+        return self.__class__("".join(temp))
 
     def to_list(self) -> List[str]:
         """
         Convert into list
-        
+
         Returns
         -------
         list[str]
@@ -484,7 +564,111 @@ class Text(str):
         """
         return list(self)
 
+    @versionadded(version="3.3.0")
+    def to_listext(self) -> "ListExt":
+        """
+        Convert into ``ListExt``
+
+        Returns
+        -------
+        ListExt[str]
+            List of string
+
+
+        Example:
+        --------
+        >>> test = Text("test")
+        >>> test.to_listext()
+        ['t', 'e', 's', 't']
+        """
+        return ListExt(self)
+
+    @versionadded(version="3.3.0")
+    def count_pattern(self, pattern: str, ignore_capslock: bool = False) -> int:
+        """
+        Returns how many times ``pattern`` appears in text
+        (Inspired by hackerrank exercise)
 
+        Parameters
+        ----------
+        pattern : str
+            Pattern to count
+
+        ignore_capslock : bool
+            Ignore the pattern uppercase or lowercase
+            (Default: ``False`` - Exact match)
+
+        Returns
+        -------
+        int
+            How many times pattern appeared
+
+
+        Example:
+        --------
+        >>> Text("test").count_pattern("t")
+        2
+        """
+        if len(pattern) > len(self):
+            raise ValueError(f"len(pattern) must not larger than {len(self)}")
+
+        temp = str(self)
+        if ignore_capslock:
+            pattern = pattern.lower()
+            temp = temp.lower()
+
+        out = [
+            1
+            for i in range(len(temp) - len(pattern) + 1)
+            if temp[i : i + len(pattern)] == pattern
+        ]
+        return sum(out)
+
+    @versionadded(version="3.3.0")
+    def hapax(self, strict: bool = False) -> List[str]:
+        """
+        A hapax legomenon (often abbreviated to hapax)
+        is a word which occurs only once in either
+        the written record of a language, the works of
+        an author, or in a single text.
+
+        This function returns a list of hapaxes (if any)
+        (Lettercase is ignored)
+
+        Parameters
+        ----------
+        strict : bool
+            Remove all special characters before checking for hapax
+            (Default: ``False``)
+
+        Returns
+        -------
+        list[str]
+            A list of hapaxes
+
+
+        Example:
+        --------
+        >>> test = Text("A a. a, b c c= C| d d")
+        >>> test.hapax()
+        ['a', 'a.', 'a,', 'b', 'c', 'c=', 'c|']
+
+        >>> test.hapax(strict=True)
+        ['b']
+        """
+        word_list: List[str] = self.lower().split()
+        if strict:
+            remove_characters: List[str] = list(r"\"'.,:;|()[]{}\/!@#$%^&*-_=+?<>`~")
+            temp = str(self)
+            for x in remove_characters:
+                temp = temp.replace(x, "")
+            word_list = temp.lower().split()
+
+        hapaxes = filter(lambda x: word_list.count(x) == 1, word_list)
+        return list(hapaxes)
+
+
+# MARK: IntNumber
 class IntNumber(int):
     """
     ``int`` extension
@@ -640,7 +824,7 @@ class IntNumber(int):
             # a perfect number have a form of (2**(n-1))*((2**n)-1)
             perfect_number.append((2**(x-1))*((2**x)-1))
         """
-        number = self
+        number = int(self)
 
         perfect_number = [
             6,
@@ -653,15 +837,15 @@ class IntNumber(int):
             2_305_843_008_139_952_128,
         ]
 
-        if int(number) in perfect_number:
+        if number in perfect_number:
             return True
 
-        elif int(number) < perfect_number[-1]:
+        elif number < perfect_number[-1]:
             return False
 
         else:
             # Faster way to check
-            perfect_number_index = [
+            perfect_number_index: List[int] = [
                 61,
                 89,
                 107,
@@ -709,9 +893,9 @@ class IntNumber(int):
             for x in perfect_number_index:
                 # a perfect number have a form of (2**(n-1))*((2**n)-1)
                 perfect_number = (2 ** (x - 1)) * ((2**x) - 1)
-                if number < perfect_number:
+                if number < perfect_number:  # type: ignore
                     return False
-                elif number == perfect_number:
+                elif number == perfect_number:  # type: ignore
                     return True
 
             # Manual way when above method not working
@@ -721,7 +905,7 @@ class IntNumber(int):
             i = 2
             while i * i <= number:
                 if number % i == 0:
-                    s += +i + number / i
+                    s += +i + number / i  # type: ignore
                 i += 1
             # s == number -> perfect
             return True if s == number and number != 1 else False
@@ -745,8 +929,9 @@ class IntNumber(int):
         """
         try:
             check = sum([int(x) ** len(str(self)) for x in str(self)])
-            return self == check
-        except:
+            res = int(self) == check
+            return res  # type: ignore
+        except Exception:
             return False
 
     def reverse(self) -> "IntNumber":
@@ -765,10 +950,10 @@ class IntNumber(int):
         >>> test.reverse()
         201
         """
-        number = self
+        number = int(self)
         if number <= 1:
             number *= -1
-        return __class__(str(number)[::-1])
+        return self.__class__(str(number)[::-1])
 
     def is_palindromic(self) -> bool:
         """
@@ -797,6 +982,7 @@ class IntNumber(int):
         return self.is_palindromic() and self.is_prime()
 
     # calculation stuff
+    @versionchanged(version="3.3.0", reason="Fix bug")
     def lcm(self, with_number: int) -> "IntNumber":
         """
         Least common multiple of ``self`` and ``with_number``
@@ -818,8 +1004,12 @@ class IntNumber(int):
         >>> test.lcm(5)
         510
         """
-        return __class__((self * with_number) // math.gcd(self, with_number))
+        try:
+            return self.__class__(math.lcm(self, with_number))
+        except AttributeError:  # Python < 3.9
+            return self.__class__((self * with_number) // math.gcd(self, with_number))
 
+    @versionchanged(version="3.3.0", reason="Fix bug")
     def gcd(self, with_number: int) -> "IntNumber":
         """
         Greatest common divisor of ``self`` and ``with_number``
@@ -841,10 +1031,7 @@ class IntNumber(int):
         >>> test.gcd(8)
         8
         """
-        if python_version.micro < 9:
-            return __class__(math.gcd(self, with_number))
-        else:
-            return __class__(math.lcm(self, with_number))
+        return self.__class__(math.gcd(self, with_number))
 
     def add_to_one_digit(self, master_number: bool = False) -> "IntNumber":
         """
@@ -873,7 +1060,7 @@ class IntNumber(int):
         >>> test.add_to_one_digit(master_number=True)
         11
         """
-        number = self
+        number = int(self)
         if number < 0:
             number *= -1
         logger.debug(f"Current number: {number}")
@@ -883,7 +1070,7 @@ class IntNumber(int):
                 if number == 22 or number == 11:
                     break  # Master number
             logger.debug(f"Sum after loop: {number}")
-        return __class__(number)
+        return self.__class__(number)
 
     def divisible_list(self, short_form: bool = True) -> List[int]:
         """
@@ -1024,9 +1211,10 @@ class IntNumber(int):
             characteristic = DictBoolTrue(characteristic)
 
         output["characteristic"] = characteristic
-        return output
+        return output  # type: ignore
 
 
+# MARK: ListExt
 class ListExt(list):
     """
     ``list`` extension
@@ -1065,7 +1253,9 @@ class ListExt(list):
         list
             Filtered list
         """
-        number_of_items = 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:
@@ -1083,7 +1273,9 @@ class ListExt(list):
         list
             Filtered list
         """
-        number_of_items = 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]
 
     def sorts(self, reverse: bool = False) -> "ListExt":
@@ -1110,7 +1302,7 @@ class ListExt(list):
         [1, 9, 'aaa', 'abc', 1.4, 3.5]
         """
         lst = self.copy()
-        type_weights = {}
+        type_weights: dict = {}
         for x in lst:
             if type(x) not in type_weights:
                 type_weights[type(x)] = len(type_weights)
@@ -1121,14 +1313,14 @@ class ListExt(list):
         )
 
         logger.debug(output)
-        return __class__(output)
+        return self.__class__(output)
 
     def freq(
         self,
         sort: bool = False,
         num_of_first_char: Optional[int] = None,
         appear_increment: bool = False,
-    ):
+    ) -> Union[dict, List[int]]:
         """
         Find frequency of each item in list
 
@@ -1140,7 +1332,7 @@ class ListExt(list):
 
         num_of_first_char : int | None
             | Number of first character taken into account to sort
-            | (Default: None)
+            | (Default: ``None``)
             | (num_of_first_char = ``1``: first character in each item)
 
         appear_increment : bool
@@ -1152,7 +1344,7 @@ class ListExt(list):
         dict
             A dict that show frequency
 
-        list
+        list[int]
             Incremental index list
 
 
@@ -1168,14 +1360,14 @@ class ListExt(list):
         """
 
         if sort:
-            data = self.sorts()
+            data = self.sorts().copy()
         else:
             data = self.copy()
 
         if num_of_first_char is None:
             temp = Counter(data)
         else:
-            max_char = min([len(str(x)) for x in data])
+            max_char: int = min([len(str(x)) for x in data])
             logger.debug(f"Max character: {max_char}")
             if num_of_first_char not in range(1, max_char):
                 logger.debug(f"Not in {range(1, max_char)}. Using default value...")
@@ -1186,12 +1378,12 @@ class ListExt(list):
 
         try:
             times_appear = dict(sorted(temp.items()))
-        except:
-            times_appear = dict(__class__(temp.items()).sorts())
+        except Exception:
+            times_appear = dict(self.__class__(temp.items()).sorts())
         logger.debug(times_appear)
 
         if appear_increment:
-            times_appear_increment = list(
+            times_appear_increment: List[int] = list(
                 accumulate(times_appear.values(), operator.add)
             )
             logger.debug(times_appear_increment)
@@ -1329,7 +1521,7 @@ class ListExt(list):
         ['1', '2', '3']
         """
         # return __class__(func(x) for x in self)
-        return __class__(map(func, self))
+        return self.__class__(map(func, self))
 
     def unique(self) -> "ListExt":
         """
@@ -1347,7 +1539,7 @@ class ListExt(list):
         >>> test.unique()
         [1, 2, 3]
         """
-        return __class__(set(self))
+        return self.__class__(set(self))
 
     def group_by_unique(self) -> "ListExt":
         """
@@ -1371,7 +1563,7 @@ class ListExt(list):
 
         # New
         temp = groupby(self.sorts())
-        return __class__([list(g) for _, g in temp])
+        return self.__class__([list(g) for _, g in temp])
 
     @staticmethod
     def _group_by_unique(iterable: list) -> List[list]:
@@ -1414,7 +1606,7 @@ class ListExt(list):
         iter = self.copy()
 
         # Init loop
-        for _ in range(set_min(max_loop, min_value=3)):
+        for _ in range(int(set_min(max_loop, min_value=3))):
             temp: Dict[Any, list] = {}
             # Make dict{key: all `item` that contains `key`}
             for item in iter:
@@ -1450,7 +1642,7 @@ class ListExt(list):
         """
         try:
             return ListExt(chain(*self))
-        except:
+        except Exception:
             temp = list(map(lambda x: x if isinstance(x, list) else [x], self))
             return ListExt(chain(*temp))
 
@@ -1477,7 +1669,7 @@ class ListExt(list):
         >>> test.numbering()
         [(0, 9), (1, 9), (2, 9)]
         """
-        start = set_min(start, min_value=0)
+        start = int(set_min(start, min_value=0))
         return ListExt(enumerate(self, start=start))
 
     @staticmethod
@@ -1485,16 +1677,21 @@ class ListExt(list):
         """
         Static method for ``numbering``
         """
-        start = set_min(start, min_value=0)
+        start = int(set_min(start, min_value=0))
         return list(enumerate(iterable, start=start))
 
 
+# MARK: DictExt
 class DictExt(dict):
     """
     ``dict`` extension
     """
 
-    def analyze(self) -> dict:
+    @versionchanged(
+        version="3.3.0",
+        reason="Change function output; Before: <dict>, Now: DictAnalyzeResult",
+    )
+    def analyze(self) -> DictAnalyzeResult:
         """
         Analyze all the key values (``int``, ``float``)
         in ``dict`` then return highest/lowest index
@@ -1515,18 +1712,13 @@ class DictExt(dict):
         >>>     "mno": 1
         >>> })
         >>> test.analyze()
-        {
-            'max_value': 9,
-            'min_value': 1,
-            'max': [('abc', 9), ('def', 9)],
-            'min': [('jkl', 1), ('mno', 1)]
-        }
+        DictAnalyzeResult(max_value=9, min_value=1, max_list=[('abc', 9), ('def', 9)], min_list=[('jkl', 1), ('mno', 1)])
         """
         try:
-            dct = self.copy()
+            dct: dict = self.copy()
 
-            max_val = max(list(dct.values()))
-            min_val = min(list(dct.values()))
+            max_val: Union[int, float] = max(list(dct.values()))
+            min_val: Union[int, float] = min(list(dct.values()))
             max_list = []
             min_list = []
 
@@ -1536,20 +1728,21 @@ class DictExt(dict):
                 if v == min_val:
                     min_list.append((k, v))
 
-            output = {
-                "max_value": max_val,
-                "min_value": min_val,
-                "max": max_list,
-                "min": min_list,
-            }
+            # output = {
+            #     "max_value": max_val,
+            #     "min_value": min_val,
+            #     "max": max_list,
+            #     "min": min_list,
+            # }
 
-            logger.debug(output)
-            return output
+            # logger.debug(output)
+            # return output
+            return DictAnalyzeResult(max_val, min_val, max_list, min_list)
 
-        except:
+        except Exception:
             err_msg = "Value must be int or float"
             logger.error(err_msg)
-            raise ValueError(err_msg)
+            raise ValueError(err_msg)  # noqa: B904
 
     def swap_items(self) -> "DictExt":
         """
@@ -1567,7 +1760,7 @@ class DictExt(dict):
         >>> test.swap_items()
         {9: 'abc'}
         """
-        return __class__(zip(self.values(), self.keys()))
+        return self.__class__(zip(self.values(), self.keys()))
 
     def apply(self, func: Callable, apply_to_value: bool = True) -> "DictExt":
         """
@@ -1598,13 +1791,12 @@ class DictExt(dict):
             k = self.keys()
             v = map(func, self.values())
         else:
-            k = map(func, self.keys())
-            v = self.values()
-        return __class__(zip(k, v))
+            k = map(func, self.keys())  # type: ignore
+            v = self.values()  # type: ignore
+        return self.__class__(zip(k, v))
 
 
 # Run
 ###########################################################################
 if __name__ == "__main__":
     logger.setLevel(10)
-    # from rich import print