absfuyu 2.8.1__py3-none-any.whl → 3.1.0__py3-none-any.whl

absfuyu/{collections → general}/data_extension.py

@@ -3,23 +3,37 @@ Absfuyu: Data extension
 -----------------------
 Extension for data type such as ``list``, ``str``, ``dict``, ...
 
-Version: 1.3.4
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 1.12.3
+Date updated: 23/01/2024 (dd/mm/yyyy)
 
 Features:
 ---------
 - Text
-- ListKai
-- DictKai
+- ListExt
+- DictExt
 - IntNumber
+
+Usage:
+------
+>>> from absfuyu.general.data_extension import DictExt, IntNumber, ListExt, Text
 """
 
 
 # Module level
 ###########################################################################
 __all__ = [
-    "Text", "IntNumber",
-    "ListKai", "DictKai"
+    # Main
+    "Text",
+    "IntNumber",
+    "ListExt",
+    "DictExt",
+    # Sub
+    "Pow",
+    "ListREPR",
+    "ListNoDunder",
+    "DictBoolTrue",
+    "DictBoolFalse",
+    # "DictNoDunder",
 ]
 
 
@@ -30,19 +44,117 @@ from itertools import accumulate, chain, groupby
 import math
 import operator
 import random
-from typing import Any, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from sys import version_info as python_version
 
-from absfuyu.collections.generator import Generator, Charset
-from absfuyu.logger import logger
+from absfuyu.general.generator import Generator, Charset
+from absfuyu.logger import logger, _compress_list_for_print
 from absfuyu.util import set_min, set_min_max
 
 
+# Function
+###########################################################################
+def _dict_bool(dict_object: dict, option: bool) -> Optional[dict]:
+    """
+    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
+
+
+# Sub class
+###########################################################################
+class Pow:
+    """Number power by a number"""
+
+    def __init__(self, number: Union[int, float], power_by: Union[int, float]) -> None:
+        self.number = number
+        self.power_by = power_by
+
+    def __str__(self) -> str:
+        if self.power_by == 1:
+            return str(self.number)
+        else:
+            return f"{self.number}^{self.power_by}"
+        # return f"{self.__class__.__name__}({self.number}, {self.power_by})"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def to_list(self) -> List[Union[int, float]]:
+        """
+        Convert into list
+
+        :rtype: list[int | float]
+        """
+        return [self.number] * self.power_by
+
+    def calculate(self) -> float:
+        """
+        Calculate the ``self.number`` to the power of ``self.power_by``
+
+        :rtype: float
+        """
+        # return self.number**self.power_by
+        return math.pow(self.number, self.power_by)
+
+
+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 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 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__()
+
+
 # Class
 ###########################################################################
 class Text(str):
     """
     ``str`` extension
     """
+
     def divide(self, string_split_size: int = 60) -> list:
         """
         Divide long string into smaller size
@@ -59,7 +171,7 @@ class Text(str):
             A list in which each item is a smaller
             string with the size of ``string_split_size``
             (need to be concaternate later)
-        
+
 
         Example:
         --------
@@ -73,13 +185,13 @@ class Text(str):
             output.append(temp[:string_split_size])
             temp = temp[string_split_size:]
         return output
-    
+
     def divide_with_variable(
-            self,
-            split_size: int = 60,
-            split_var_len: int = 12,
-            custom_var_name: Optional[str] = None,
-        ) -> list:
+        self,
+        split_size: int = 60,
+        split_var_len: int = 12,
+        custom_var_name: Optional[str] = None,
+    ) -> list:
         """
         Divide long string into smaller size,
         then assign a random variable to splited
@@ -90,11 +202,11 @@ class Text(str):
         split_size : int
             Divide string every ``x`` character
             (Default: ``60``)
-        
+
         split_var_len : int
             Length of variable name assigned to each item
             (Default: ``12``)
-        
+
         custom_var_name : str
             Custom variable name when join string
 
@@ -129,30 +241,28 @@ class Text(str):
 
         temp = self.divide(split_size)
         output = []
-        
+
         # split variable
         splt_var_len = split_var_len
         splt_len = len(temp)
 
         if custom_var_name is None:
             splt_name = Generator.generate_string(
-                charset=Charset.ALPHABET,
-                size=split_var_len,
-                times=splt_len+1
+                charset=Charset.ALPHABET, size=split_var_len, times=splt_len + 1
             )
             for i in range(splt_len):
                 output.append(f"{splt_name[i]}='{temp[i]}'")
         else:
             for i in range(splt_len):
                 output.append(f"{custom_var_name}{i+1}='{temp[i]}'")
-        
+
         # joined variable
         temp = []
         if custom_var_name is None:
             for i in range(splt_len):
                 if i == 0:
                     temp.append(f"{splt_name[-1]}=")
-                if (i == splt_len-1):
+                if i == splt_len - 1:
                     temp.append(f"{splt_name[i]}")
                 else:
                     temp.append(f"{splt_name[i]}+")
@@ -160,11 +270,11 @@ class Text(str):
             for i in range(splt_len):
                 if i == 0:
                     temp.append(f"{custom_var_name}=")
-                if (i == splt_len-1):
+                if i == splt_len - 1:
                     temp.append(f"{custom_var_name}{i+1}")
                 else:
                     temp.append(f"{custom_var_name}{i+1}+")
-        
+
         output.append("".join(temp))
         if custom_var_name is None:
             output.append(splt_name[-1])
@@ -173,7 +283,6 @@ class Text(str):
 
         return output
 
-
     def analyze(self) -> dict:
         """
         String analyze (count number of type of character)
@@ -184,8 +293,8 @@ class Text(str):
             A dictionary contains number of digit character,
             uppercase character, lowercase character, and
             special character
-        
-            
+
+
         Example:
         --------
         >>> test = Text("Random T3xt!")
@@ -195,36 +304,30 @@ class Text(str):
 
         temp = self
 
-        detail = {
-            "digit": 0,
-            "uppercase": 0,
-            "lowercase": 0,
-            "other": 0
-        }
+        detail = {"digit": 0, "uppercase": 0, "lowercase": 0, "other": 0}
 
         for x in temp:
-            if ord(x) in range(48, 58): #num
+            if ord(x) in range(48, 58):  # num
                 detail["digit"] += 1
-            elif ord(x) in range(65, 91): #cap
+            elif ord(x) in range(65, 91):  # cap
                 detail["uppercase"] += 1
-            elif ord(x) in range(97, 123): #low
+            elif ord(x) in range(97, 123):  # low
                 detail["lowercase"] += 1
             else:
                 detail["other"] += 1
-        
+
         return detail
-    
 
-    def reverse(self):
+    def reverse(self) -> "Text":
         """
         Reverse the string
-        
+
         Returns
         -------
         Text
             Reversed string
-        
-            
+
+
         Example:
         --------
         >>> test = Text("Hello, World!")
@@ -233,7 +336,6 @@ class Text(str):
         """
         return __class__(self[::-1])
 
-
     def is_pangram(self) -> bool:
         """
         Check if string is a pangram
@@ -255,7 +357,7 @@ class Text(str):
         """
         Check if string is a palindrome
 
-            A palindrome is a word, verse, or sentence 
+            A palindrome is a word, verse, or sentence
             or a number that reads the same backward or forward
 
         Returns
@@ -267,7 +369,7 @@ class Text(str):
         text = self
         # Use string slicing [start:end:step]
         return text == text[::-1]
-    
+
     def to_hex(self, raw: bool = False) -> str:
         r"""
         Convert string to hex form
@@ -291,10 +393,10 @@ class Text(str):
         '\\x48\\x65\\x6c\\x6c\\x6f\\x2c\\x20\\x57\\x6f\\x72\\x6c\\x64\\x21'
         """
         text = self
-        
+
         byte_str = text.encode("utf-8")
         hex_str = byte_str.hex()
-              
+
         if not raw:
             temp = []
             str_len = len(hex_str)
@@ -307,7 +409,7 @@ class Text(str):
         else:
             return hex_str
 
-    def random_capslock(self, probability: int = 50):
+    def random_capslock(self, probability: int = 50) -> "Text":
         """
         Randomly capslock letter in string
 
@@ -316,7 +418,7 @@ class Text(str):
         probability : int
             Probability in range [0, 100]
             (Default: ``50``)
-        
+
         Returns
         -------
         Text
@@ -331,7 +433,7 @@ class Text(str):
         """
         probability = set_min_max(probability)
         text = self.lower()
-        
+
         temp = []
         for x in text:
             if random.randint(1, 100) <= probability:
@@ -340,22 +442,65 @@ class Text(str):
         logger.debug(temp)
         return __class__("".join(temp))
 
+    def reverse_capslock(self) -> "Text":
+        """
+        Reverse capslock in string
+
+        Returns
+        -------
+        Text
+            Reversed capslock ``Text``
+
+
+        Example:
+        --------
+        >>> test = Text("Foo")
+        >>> test.reverse_capslock()
+        'fOO'
+        """
+        temp = list(self)
+        for i, x in enumerate(temp):
+            if x.isupper():
+                temp[i] = x.lower()
+            else:
+                temp[i] = x.upper()
+        return __class__("".join(temp))
+
+    def to_list(self) -> List[str]:
+        """
+        Convert into list
+        
+        Returns
+        -------
+        list[str]
+            List of string
+
+
+        Example:
+        --------
+        >>> test = Text("test")
+        >>> test.to_list()
+        ['t', 'e', 's', 't']
+        """
+        return list(self)
+
 
 class IntNumber(int):
     """
     ``int`` extension
     """
+
     # convert stuff
     def to_binary(self) -> str:
         """
         Convert to binary number
-        
+
         Returns
         -------
         str
             Binary number
-        
-        
+
+
         Example:
         --------
         >>> test = IntNumber(10)
@@ -363,7 +508,7 @@ class IntNumber(int):
         '1010'
         """
         return format(self, "b")
-    
+
     def to_celcius_degree(self) -> float:
         """
         Convert into Celcius degree as if ``self`` is Fahrenheit degree
@@ -382,7 +527,7 @@ class IntNumber(int):
         """
         c_degree = (self - 32) / 1.8
         return c_degree
-    
+
     def to_fahrenheit_degree(self) -> float:
         """
         Convert into Fahrenheit degree as if ``self`` is Celcius degree
@@ -402,8 +547,19 @@ class IntNumber(int):
         f_degree = (self * 1.8) + 32
         return f_degree
 
-
     # is_stuff
+    def is_even(self) -> bool:
+        """
+        An even number is a number which divisible by 2
+
+        Returns
+        -------
+        bool
+            | ``True`` if an even number
+            | ``False`` if not an even number
+        """
+        return self % 2 == 0
+
     def is_prime(self) -> bool:
         """
         Check if the integer is a prime number or not
@@ -420,14 +576,14 @@ class IntNumber(int):
             | ``False`` if not a prime number
         """
         number = self
-        
-        if int(number) <= 1:
+
+        if number <= 1:
             return False
-        for i in range(2, int(math.sqrt(number)) + 1):# divisor range
-            if (number % i == 0):
+        for i in range(2, int(math.sqrt(number)) + 1):  # divisor range
+            if number % i == 0:
                 return False
         return True
-    
+
     def is_twisted_prime(self) -> bool:
         """
         A number is said to be twisted prime if
@@ -445,7 +601,7 @@ class IntNumber(int):
         rev = self.reverse().is_prime()
         logger.debug(f"is prime when reversed: {rev}")
         return prime and rev
-    
+
     def is_perfect(self) -> bool:
         """
         Check if integer is perfect number
@@ -494,15 +650,15 @@ class IntNumber(int):
             33_550_336,
             8_589_869_056,
             137_438_691_328,
-            2_305_843_008_139_952_128
+            2_305_843_008_139_952_128,
         ]
-        
+
         if int(number) in perfect_number:
             return True
-        
+
         elif int(number) < perfect_number[-1]:
             return False
-        
+
         else:
             # Faster way to check
             perfect_number_index = [
@@ -551,13 +707,13 @@ class IntNumber(int):
                 ## 82_589_933
             ]
             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))
+                # 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:
                     return False
                 elif number == perfect_number:
                     return True
-            
+
             # Manual way when above method not working
             # sum
             s = 1
@@ -565,10 +721,10 @@ class IntNumber(int):
             i = 2
             while i * i <= number:
                 if number % i == 0:
-                    s += + i + number/i
+                    s += +i + number / i
                 i += 1
             # s == number -> perfect
-            return (True if s == number and number!=1 else False)
+            return True if s == number and number != 1 else False
 
     def is_narcissistic(self) -> bool:
         """
@@ -580,34 +736,40 @@ class IntNumber(int):
             or a plus perfect number) in a given number base ``b``
             is a number that is the sum of its own digits
             each raised to the power of the number of digits.
-        
+
         Returns
         -------
         bool
             | ``True`` if a narcissistic number
             | ``False`` if not a narcissistic number
         """
-        check = sum([int(x) ** len(str(self)) for x in str(self)])
-        return self == check
+        try:
+            check = sum([int(x) ** len(str(self)) for x in str(self)])
+            return self == check
+        except:
+            return False
 
-    def reverse(self):
+    def reverse(self) -> "IntNumber":
         """
-        Reverse a number
-        
+        Reverse a number. Reverse ``abs(number)`` if ``number < 0``
+
         Returns
         -------
         IntNumber
             Reversed number
-        
-            
+
+
         Example:
         --------
         >>> test = IntNumber(102)
         >>> test.reverse()
         201
         """
-        return __class__(str(self)[::-1])
-    
+        number = self
+        if number <= 1:
+            number *= -1
+        return __class__(str(number)[::-1])
+
     def is_palindromic(self) -> bool:
         """
         A palindromic number (also known as a numeral palindrome
@@ -621,7 +783,7 @@ class IntNumber(int):
             | ``False`` if not a palindromic number
         """
         return self == self.reverse()
-    
+
     def is_palindromic_prime(self) -> bool:
         """
         A palindormic prime is a number which is both palindromic and prime
@@ -633,10 +795,9 @@ class IntNumber(int):
             | ``False`` if not a palindormic prime number
         """
         return self.is_palindromic() and self.is_prime()
-    
 
     # calculation stuff
-    def lcm(self, with_number: int):
+    def lcm(self, with_number: int) -> "IntNumber":
         """
         Least common multiple of ``self`` and ``with_number``
 
@@ -658,15 +819,41 @@ class IntNumber(int):
         510
         """
         return __class__((self * with_number) // math.gcd(self, with_number))
-    
-    def add_to_one_digit(self, master_number: bool = False):
+
+    def gcd(self, with_number: int) -> "IntNumber":
+        """
+        Greatest common divisor of ``self`` and ``with_number``
+
+        Parameters
+        ----------
+        with_number : int
+            The number that want to find GCD with
+
+        Returns
+        -------
+        IntNumber
+            Greatest common divisor
+
+
+        Example:
+        --------
+        >>> test = IntNumber(1024)
+        >>> test.gcd(8)
+        8
+        """
+        if python_version.micro < 9:
+            return __class__(math.gcd(self, with_number))
+        else:
+            return __class__(math.lcm(self, with_number))
+
+    def add_to_one_digit(self, master_number: bool = False) -> "IntNumber":
         """
-        Convert ``self`` into 1-digit number 
+        Convert ``self`` into 1-digit number
         by adding all of the digits together
 
         Parameters
         ----------
-        master_number: bool
+        master_number : bool
             | Break when sum = ``22`` or ``11`` (numerology)
             | (Default: ``False``)
 
@@ -687,42 +874,222 @@ class IntNumber(int):
         11
         """
         number = self
+        if number < 0:
+            number *= -1
         logger.debug(f"Current number: {number}")
         while len(str(number)) != 1:
             number = sum(map(int, str(number)))
             if master_number:
                 if number == 22 or number == 11:
-                    break # Master number
+                    break  # Master number
             logger.debug(f"Sum after loop: {number}")
         return __class__(number)
 
+    def divisible_list(self, short_form: bool = True) -> List[int]:
+        """
+        A list of divisible number
+
+        Parameters
+        ----------
+        short_form : bool
+            | Show divisible list in short form
+            | Normal example: ``[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]``
+            | Short form example: ``[1, 2, 4, 8, ...,128, 256, 512, 1024] [Len: 11]``
+            | (Default: ``True``)
+
+        Returns
+        -------
+        list[int]
+            A list of divisible number
+
+
+        Example:
+        --------
+        >>> test = IntNumber(1024)
+        >>> test.divisible_list(short_form=False)
+        [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
+        """
+
+        if self <= 1:
+            return [1]
+        divi_list = [x for x in range(1, int(self / 2) + 1) if self % x == 0] + [self]
+
+        if short_form:
+            return divi_list
+            # return ListREPR(divi_list) ## FIX LATER
+        return divi_list
+
+    def prime_factor(self, short_form: bool = True) -> Union[List[int], List[Pow]]:
+        """
+        Prime factor
 
-class ListKai(list):
+        Parameters
+        ----------
+        short_form : bool
+            | Show prime list in short form
+            | Normal example: ``[2, 2, 2, 3, 3]``
+            | Short form example: ``[2^3, 3^2]``
+            | (Default: ``True``)
+
+        Returns
+        -------
+        list[int] | list[Pow]
+            | List of prime number that when multiplied together == ``self``
+            | list[int]: Long form
+            | list[Pow]: Short form
+
+
+        Example:
+        --------
+        >>> test = IntNumber(1024)
+        >>> test.prime_factor()
+        [2^10]
+
+        >>> test = IntNumber(1024)
+        >>> test.prime_factor(short_form=False)
+        [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
+        """
+        # Generate list
+        factors = []
+        divisor = 2
+        number = int(self)
+        if number <= 1:
+            return [number]
+        while divisor <= number:
+            if number % divisor == 0:
+                factors.append(divisor)
+                number //= divisor  # number = number // divisor
+            else:
+                divisor += 1
+
+        # Output
+        if short_form:
+            temp = dict(Counter(factors))
+            return [Pow(k, v) for k, v in temp.items()]
+        return factors
+
+    # analyze
+    def analyze(self, short_form: bool = True) -> Dict[str, Dict[str, Any]]:
+        """
+        Analyze the number with almost all ``IntNumber`` method
+
+        Parameters
+        ----------
+        short_form : bool
+            | Enable short form for some items
+            | (Default: ``True``)
+
+        Returns
+        -------
+        dict[str, dict[str, Any]]
+            Detailed analysis
+
+
+        Example:
+        --------
+        >>> test = IntNumber(1024)
+        >>> test.analyze()
+        {
+            'summary': {'number': 1024, 'length': 4, 'even': True, 'prime factor': [2^10], 'divisible': [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]},
+            'convert': {'binary': '10000000000', 'octa': '2000', 'hex': '400', 'reverse': 4201, 'add to one': 7},
+            'characteristic': {'prime': False, 'twisted prime': False, 'perfect': False, 'narcissistic': False, 'palindromic': False, 'palindromic prime': False}
+        }
+        """
+        output = {
+            "summary": {
+                "number": self,
+                "length": len(str(self)),
+                "even": self.is_even(),
+                "prime factor": self.prime_factor(short_form=short_form),
+                "divisible": self.divisible_list(short_form=short_form),
+            },
+            "convert": {
+                "binary": bin(self)[2:],
+                "octa": oct(self)[2:],
+                "hex": hex(self)[2:],
+                # "hash": hash(self),
+                "reverse": self.reverse(),
+                "add to one": self.add_to_one_digit(),
+            },
+        }
+        characteristic = {
+            "prime": self.is_prime(),
+            "twisted prime": self.is_twisted_prime(),
+            "perfect": self.is_perfect(),
+            "narcissistic": self.is_narcissistic(),
+            "palindromic": self.is_palindromic(),
+            "palindromic prime": self.is_palindromic_prime(),
+        }
+        if short_form:
+            characteristic = DictBoolTrue(characteristic)
+
+        output["characteristic"] = characteristic
+        return output
+
+
+class ListExt(list):
     """
     ``list`` extension
     """
-    def stringify(self):
+
+    def stringify(self) -> "ListExt":
         """
         Convert all item in ``list`` into string
 
         Returns
         -------
-        ListKai
-            A list with all items with type: string
+        ListExt
+            A list with all items with type <str`>
 
 
         Example:
         --------
-        >>> test = ListKai([1, 1, 1, 2, 2, 3])
+        >>> test = ListExt([1, 1, 1, 2, 2, 3])
         >>> test.stringify()
         ['1', '1', '1', '2', '2', '3']
         """
-        return ListKai(map(str, self))
+        return ListExt(map(str, self))
+
+    def head(self, number_of_items: int = 5) -> list:
+        """
+        Show first ``number_of_items`` items in ``ListExt``
+
+        Parameters
+        ----------
+        number_of_items : int
+            | Number of items to shows at once
+            | (Default: ``5``)
 
-    def sorts(self, reverse: bool = False):
+        Returns
+        -------
+        list
+            Filtered list
+        """
+        number_of_items = 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:
+        """
+        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
+        """
+        number_of_items = 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":
         """
         Sort all items (with different type) in ``list``
-        
+
         Parameters
         ----------
         reverse : bool
@@ -732,13 +1099,13 @@ class ListKai(list):
 
         Returns
         -------
-        ListKai
+        ListExt
             A sorted list
 
 
         Example:
         --------
-        >>> test = ListKai([9, "abc", 3.5, "aaa", 1, 1.4])
+        >>> test = ListExt([9, "abc", 3.5, "aaa", 1, 1.4])
         >>> test.sorts()
         [1, 9, 'aaa', 'abc', 1.4, 3.5]
         """
@@ -750,20 +1117,18 @@ class ListKai(list):
         logger.debug(f"Type weight: {type_weights}")
 
         output = sorted(
-            lst,
-            key=lambda x: (type_weights[type(x)], str(x)),
-            reverse=reverse
+            lst, key=lambda x: (type_weights[type(x)], str(x)), reverse=reverse
         )
 
         logger.debug(output)
         return __class__(output)
-    
+
     def freq(
-            self,
-            sort: bool = False,
-            num_of_first_char: Optional[int] = None,
-            appear_increment: bool = False
-        ):
+        self,
+        sort: bool = False,
+        num_of_first_char: Optional[int] = None,
+        appear_increment: bool = False,
+    ):
         """
         Find frequency of each item in list
 
@@ -772,12 +1137,12 @@ class ListKai(list):
         sort : bool
             | if ``True``: Sorts the output in ascending order
             | if ``False``: No sort
-        
+
         num_of_first_char : int | None
             | Number of first character taken into account to sort
             | (Default: None)
             | (num_of_first_char = ``1``: first character in each item)
-        
+
         appear_increment : bool
             | return incremental index list of each item when sort
             | (Default: ``False``)
@@ -786,18 +1151,18 @@ class ListKai(list):
         -------
         dict
             A dict that show frequency
-        
+
         list
             Incremental index list
-        
+
 
         Example:
         --------
-        >>> test = ListKai([1, 1, 2, 3, 5, 5])
+        >>> test = ListExt([1, 1, 2, 3, 5, 5])
         >>> test.freq()
         {1: 2, 2: 1, 3: 1, 5: 2}
 
-        >>> test = ListKai([1, 1, 2, 3, 3, 4, 5, 6])
+        >>> test = ListExt([1, 1, 2, 3, 3, 4, 5, 6])
         >>> test.freq(appear_increment=True)
         [2, 3, 5, 6, 7, 8]
         """
@@ -806,7 +1171,7 @@ class ListKai(list):
             data = self.sorts()
         else:
             data = self.copy()
-        
+
         if num_of_first_char is None:
             temp = Counter(data)
         else:
@@ -818,21 +1183,23 @@ class ListKai(list):
             else:
                 logger.debug(f"Freq of first {num_of_first_char} char")
                 temp = Counter([str(x)[:num_of_first_char] for x in data])
-        
+
         try:
             times_appear = dict(sorted(temp.items()))
         except:
             times_appear = dict(__class__(temp.items()).sorts())
         logger.debug(times_appear)
-        
+
         if appear_increment:
-            times_appear_increment = list(accumulate(times_appear.values(), operator.add))
+            times_appear_increment = list(
+                accumulate(times_appear.values(), operator.add)
+            )
             logger.debug(times_appear_increment)
             return times_appear_increment
         else:
             return times_appear
 
-    def slice_points(self, points: list):
+    def slice_points(self, points: list) -> List[list]:
         """
         Slices a list at specific indices into constituent lists.
 
@@ -840,7 +1207,7 @@ class ListKai(list):
         ----------
         points : list
             List of indices to slice
-        
+
         Returns
         -------
         list[list]
@@ -849,28 +1216,28 @@ class ListKai(list):
 
         Example:
         --------
-        >>> test = ListKai([1, 1, 2, 3, 3, 4, 5, 6])
+        >>> test = ListExt([1, 1, 2, 3, 3, 4, 5, 6])
         >>> test.slice_points([2, 5])
         [[1, 1], [2, 3, 3], [4, 5, 6]]
         """
         points.append(len(self))
         data = self.copy()
         # return [data[points[i]:points[i+1]] for i in range(len(points)-1)]
-        return [data[i1:i2] for i1, i2 in zip([0]+points[:-1], points)]
+        return [data[i1:i2] for i1, i2 in zip([0] + points[:-1], points)]
 
-    def pick_one(self):
+    def pick_one(self) -> Any:
         """
         Pick one random items from ``list``
-        
+
         Returns
         -------
-        Any | None
+        Any
             Random value
 
 
         Example:
         --------
-        >>> test = ListKai(["foo", "bar"])
+        >>> test = ListExt(["foo", "bar"])
         >>> test.pick_one()
         'bar'
         """
@@ -880,33 +1247,50 @@ class ListKai(list):
             return out
         else:
             logger.debug("List empty!")
-            return None
-    
-    def len_items(self):
+            raise IndexError("List empty!")
+
+    def get_random(self, number_of_items: int = 5) -> list:
+        """
+        Get ``number_of_items`` random items in ``ListExt``
+
+        Parameters
+        ----------
+        number_of_items : int
+            | Number random of items
+            | (Default: ``5``)
+
+        Returns
+        -------
+        list
+            Filtered list
+        """
+        return [self.pick_one() for _ in range(number_of_items)]
+
+    def len_items(self) -> "ListExt":
         """
         ``len()`` for every item in ``list[str]``
 
         Returns
         -------
-        ListKai
+        ListExt
             List of ``len()``'ed value
 
 
         Example:
         --------
-        >>> test = ListKai(["foo", "bar", "pizza"])
+        >>> test = ListExt(["foo", "bar", "pizza"])
         >>> test.len_items()
         [3, 3, 5]
         """
-        out = ListKai([len(str(x)) for x in self])
-        # out = ListKai(map(lambda x: len(str(x)), self))
+        out = ListExt([len(str(x)) for x in self])
+        # out = ListExt(map(lambda x: len(str(x)), self))
         logger.debug(out)
         return out
 
     def mean_len(self) -> float:
         """
         Average length of every item
-        
+
         Returns
         -------
         float
@@ -915,69 +1299,69 @@ class ListKai(list):
 
         Example:
         --------
-        >>> test = ListKai(["foo", "bar", "pizza"])
+        >>> test = ListExt(["foo", "bar", "pizza"])
         >>> test.mean_len()
         3.6666666666666665
         """
-        out = sum(self.len_items())/len(self)
+        out = sum(self.len_items()) / len(self)
         logger.debug(out)
         return out
-    
-    def apply(self, func):
+
+    def apply(self, func: Callable) -> "ListExt":
         """
         Apply function to each entry
-        
+
         Parameters
         ----------
         func : Callable
             Callable function
-        
+
         Returns
         -------
-        ListKai
-            ListKai
+        ListExt
+            ListExt
 
 
         Example:
         --------
-        >>> test = ListKai([1, 2, 3])
+        >>> test = ListExt([1, 2, 3])
         >>> test.apply(str)
         ['1', '2', '3']
         """
         # return __class__(func(x) for x in self)
         return __class__(map(func, self))
 
-    def unique(self):
+    def unique(self) -> "ListExt":
         """
         Remove duplicates
 
         Returns
         -------
-        ListKai
+        ListExt
             Duplicates removed list
-        
-            
+
+
         Example:
         --------
-        >>> test = ListKai([1, 1, 1, 2, 2, 3])
+        >>> test = ListExt([1, 1, 1, 2, 2, 3])
         >>> test.unique()
         [1, 2, 3]
         """
         return __class__(set(self))
-    
-    def group_by_unique(self):
+
+    def group_by_unique(self) -> "ListExt":
         """
         Group duplicated elements into list
 
         Returns
         -------
-        ListKai
+        ListExt
             Grouped value
-        
+
 
         Example:
         --------
-        >>> test = ListKai([1, 2, 3, 1, 3, 3, 2])
+        >>> test = ListExt([1, 2, 3, 1, 3, 3, 2])
         >>> test.group_by_unique()
         [[1, 1], [2, 2], [3, 3, 3]]
         """
@@ -989,33 +1373,40 @@ class ListKai(list):
         temp = groupby(self.sorts())
         return __class__([list(g) for _, g in temp])
 
+    @staticmethod
+    def _group_by_unique(iterable: list) -> List[list]:
+        """
+        Static method for ``group_by_unique``
+        """
+        return list([list(g) for _, g in groupby(iterable)])
+
     def group_by_pair_value(self, max_loop: int = 3) -> List[list]:
         """
-        Assume each ``list`` in ``list`` is a pair value, 
+        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 = ListKai([[1, 2], [2, 3], [4, 3], [5, 6]])
+        >>> test = ListExt([[1, 2], [2, 3], [4, 3], [5, 6]])
         >>> test.group_by_pair_value()
         [[1, 2, 3, 4], [5, 6]]
 
-        >>> test = ListKai([[8, 3], [4, 6], [6, 3], [5, 2], [7, 2]])
+        >>> 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 = ListKai([["a", 4], ["b", 4], [5, "c"]])
+        >>> test = ListExt([["a", 4], ["b", 4], [5, "c"]])
         >>> test.group_by_pair_value()
         [['a', 4, 'b'], ['c', 5]]
         """
@@ -1024,7 +1415,6 @@ class ListKai(list):
 
         # Init loop
         for _ in range(set_min(max_loop, min_value=3)):
-
             temp: Dict[Any, list] = {}
             # Make dict{key: all `item` that contains `key`}
             for item in iter:
@@ -1037,19 +1427,76 @@ class ListKai(list):
             # Flatten dict.values
             for k, v in temp.items():
                 temp[k] = list(set(chain(*v)))
-            
+
             iter = list(temp.values())
 
         return list(x for x, _ in groupby(iter))
 
+    def flatten(self) -> "ListExt":
+        """
+        Flatten the list
+
+        Returns
+        -------
+        ListExt
+            Flattened list
+
 
-class DictKai(dict):
+        Example:
+        --------
+        >>> test = ListExt([["test"], ["test", "test"], ["test"]])
+        >>> test.flatten()
+        ['test', 'test', 'test', 'test']
+        """
+        try:
+            return ListExt(chain(*self))
+        except:
+            temp = list(map(lambda x: x if isinstance(x, list) else [x], self))
+            return ListExt(chain(*temp))
+
+    def numbering(self, start: int = 0) -> "ListExt":
+        """
+        Number the item in list
+        (``enumerate`` wrapper)
+
+        Parameters
+        ----------
+        start : int
+            Start from which number
+            (Default: ``0``)
+
+        Returns
+        -------
+        ListExt
+            Counted list
+
+
+        Example:
+        --------
+        >>> test = ListExt([9, 9, 9])
+        >>> test.numbering()
+        [(0, 9), (1, 9), (2, 9)]
+        """
+        start = set_min(start, min_value=0)
+        return ListExt(enumerate(self, start=start))
+
+    @staticmethod
+    def _numbering(iterable: list, start: int = 0) -> List[Tuple[int, Any]]:
+        """
+        Static method for ``numbering``
+        """
+        start = set_min(start, min_value=0)
+        return list(enumerate(iterable, start=start))
+
+
+class DictExt(dict):
     """
     ``dict`` extension
     """
+
     def analyze(self) -> dict:
         """
-        Analyze all the key values (``int``, ``float``) 
+        Analyze all the key values (``int``, ``float``)
         in ``dict`` then return highest/lowest index
 
         Returns
@@ -1060,7 +1507,7 @@ class DictKai(dict):
 
         Example:
         --------
-        >>> test = DictKai({
+        >>> test = DictExt({
         >>>     "abc": 9,
         >>>     "def": 9,
         >>>     "ghi": 8,
@@ -1093,38 +1540,71 @@ class DictKai(dict):
                 "max_value": max_val,
                 "min_value": min_val,
                 "max": max_list,
-                "min": min_list
+                "min": min_list,
             }
 
             logger.debug(output)
             return output
-        
+
         except:
             err_msg = "Value must be int or float"
             logger.error(err_msg)
             raise ValueError(err_msg)
-    
-    def swap_items(self):
+
+    def swap_items(self) -> "DictExt":
         """
         Swap ``dict.keys()`` with ``dict.values()``
 
         Returns
         -------
-        DictKai
+        DictExt
             Swapped dict
 
 
         Example:
         --------
-        >>> test = DictKai({"abc": 9})
+        >>> test = DictExt({"abc": 9})
         >>> test.swap_items()
         {9: 'abc'}
         """
         return __class__(zip(self.values(), self.keys()))
 
+    def apply(self, func: Callable, apply_to_value: bool = True) -> "DictExt":
+        """
+        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:
+            k = self.keys()
+            v = map(func, self.values())
+        else:
+            k = map(func, self.keys())
+            v = self.values()
+        return __class__(zip(k, v))
 
 
 # Run
 ###########################################################################
 if __name__ == "__main__":
     logger.setLevel(10)
+    # from rich import print