absfuyu 3.2.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

absfuyu/general/generator.py

@@ -3,8 +3,8 @@ Absfuyu: Generator
 ------------------
 This generate stuff (Not python's ``generator``)
 
-Version: 1.1.0
-Date updated: 06/03/2024 (dd/mm/yyyy)
+Version: 1.1.1
+Date updated: 05/04/2024 (dd/mm/yyyy)
 
 Features:
 ---------
@@ -14,20 +14,17 @@ Features:
 - Generate combinations of list in range
 """
 
-
 # Module level
 ###########################################################################
-__all__ = [
-    "Charset",
-    "Generator"
-]
+__all__ = ["Charset", "Generator"]
 
 
 # Library
 ###########################################################################
+import string
 from itertools import chain, combinations
 from random import choice
-import string
+
 # from string import (
 #     ascii_letters as _ascii_letters,
 #     ascii_uppercase as _ascii_uppercase,
@@ -48,6 +45,7 @@ class Charset:
     """
     Character set data class
     """
+
     DEFAULT = string.ascii_letters + string.digits
     ALPHABET = string.ascii_letters
     FULL = string.ascii_letters + string.digits + string.punctuation
@@ -56,7 +54,7 @@ class Charset:
     DIGIT = string.digits
     SPECIAL = string.punctuation
     ALL = string.printable
-    PRODUCT_KEY = "BCDFGHJKMNPQRTVWXY2346789" # Charset that various key makers use
+    PRODUCT_KEY = "BCDFGHJKMNPQRTVWXY2346789"  # Charset that various key makers use
     # DEFAULT = _ascii_letters + _digits
     # ALPHABET = _ascii_letters
     # FULL = _ascii_letters + _digits + _punctuation
@@ -67,7 +65,7 @@ class Charset:
     # ALL = _printable
 
     def __str__(self) -> str:
-        charset = [x for x in __class__.__dict__.keys() if not x.startswith("__")]
+        charset = [x for x in self.__class__.__dict__.keys() if not x.startswith("__")]
         return f"List of Character set: {charset}"
 
     def __repr__(self) -> str:
@@ -78,24 +76,27 @@ class Generator:
     """
     Generator that generate stuffs
     """
+
     def __init__(self) -> None:
         logger.debug("Class initiated!")
+
     def __str__(self) -> str:
         return f"{self.__class__.__name__}()"
+
     def __repr__(self) -> str:
         return self.__str__()
 
     @staticmethod
     def generate_string(
-            charset: str = Charset.DEFAULT,
-            size: int = 8,
-            times: int = 1,
-            unique: bool = False,
-            string_type_if_1: bool = False
-        ):
+        charset: str = Charset.DEFAULT,
+        size: int = 8,
+        times: int = 1,
+        unique: bool = False,
+        string_type_if_1: bool = False,
+    ):
         """
         Generate a list of random string from character set (Random string generator)
-        
+
         Parameters
         ----------
         charset : str
@@ -108,31 +109,31 @@ class Generator:
             - ``Charset.DIGIT``: character in [0-9]
             - ``Charset.SPECIAL``: character in [!@#$%^&*()_+=-]
             - ``Charset.ALL``: character in every printable character
-        
+
         size : int
-            Length of each string in list 
+            Length of each string in list
             (Default: ``8``)
-        
+
         times : int
-            How many random string generated 
+            How many random string generated
             (Default: ``1``)
-        
+
         unique : bool
-            Each generated text is unique 
+            Each generated text is unique
             (Default: ``False``)
-        
+
         string_type_if_1 : bool
-            Return a ``str`` type result if ``times == 1`` 
+            Return a ``str`` type result if ``times == 1``
             (Default: ``False``)
-        
+
         Returns
         -------
         list
             List of random string generated
-        
+
         str
             When ``string_type_if_1`` is ``True``
-        
+
         None
             When invalid option
 
@@ -145,15 +146,15 @@ class Generator:
 
         try:
             char_lst = list(charset)
-        except:
-            char_lst = charset
+        except Exception:
+            char_lst = charset  # type: ignore # ! review this sometime
         # logger.debug(char_lst)
 
         unique_string = []
         count = 0
         logger.debug(f"Unique generated text: {unique}")
 
-        while (count < times):
+        while count < times:
             s = "".join(choice(char_lst) for _ in range(size))
             logger.debug(f"Time generated: {count+1}. Remaining: {times-count-1}. {s}")
             if not unique:
@@ -163,39 +164,39 @@ class Generator:
                 if s not in unique_string:
                     unique_string.append(s)
                     count += 1
-        
+
         logger.debug(unique_string)
         if string_type_if_1 and times == 1:
             return unique_string[0]
         else:
             return unique_string
-    
+
     @staticmethod
     def generate_key(
-            charset: str = Charset.PRODUCT_KEY,
-            letter_per_block: int = 5,
-            number_of_block: int = 5,
-            sep: str = "-"
-        ) -> str:
+        charset: str = Charset.PRODUCT_KEY,
+        letter_per_block: int = 5,
+        number_of_block: int = 5,
+        sep: str = "-",
+    ) -> str:
         """
         Generate custom key
 
         Parameters
         ----------
         charset : str
-            Character set 
+            Character set
             (Default: ``Charset.PRODUCT_KEY``)
-        
+
         letter_per_block : int
-            Number of letter per key block 
+            Number of letter per key block
             (Default: ``5``)
-        
+
         number_of_block : int
-            Number of key block 
+            Number of key block
             (Default: ``5``)
-        
+
         sep : str
-            Key block separator 
+            Key block separator
             (Default: ``-``)
 
         Returns
@@ -210,12 +211,12 @@ class Generator:
         'VKKPJVYD2H-M7R687QCV2'
         """
         out = sep.join(
-            __class__.generate_string(
+            __class__.generate_string(  # type: ignore
                 charset,
                 size=letter_per_block,
                 times=number_of_block,
                 unique=False,
-                string_type_if_1=False
+                string_type_if_1=False,
             )
         )
         logger.debug(out)
@@ -225,7 +226,7 @@ class Generator:
     def generate_check_digit(number: int) -> int:
         """
         Check digit generator
-        
+
             "A check digit is a form of redundancy check used for
             error detection on identification numbers, such as
             bank account numbers, which are used in an application
@@ -238,20 +239,20 @@ class Generator:
             the input of a series of characters (usually digits)
             such as a single mistyped digit or some permutations
             of two successive digits." (Wikipedia)
-            
+
             This function use Luhn's algorithm to calculate
-        
+
         Parameters
         ----------
         number : int
             Number to calculate check digit
-        
+
         Returns
         -------
         int
             Check digit
-        
-            
+
+
         Example:
         --------
         >>> Generator.generate_check_digit("4129984562545")
@@ -265,22 +266,24 @@ class Generator:
         logger.debug(f"Reversed: {''.join(num)}")
         for i in range(len(num)):
             # convert back into integer
-            num[i] = int(num[i])
-            if i%2 == 0:
+            num[i] = int(num[i])  # type: ignore
+            if i % 2 == 0:
                 # double value of the even-th digit
                 num[i] *= 2
                 # sum the character of digit if it's >= 10
-                if num[i] >= 10:
-                    num[i] -= 9
-            sum += num[i]
+                if num[i] >= 10:  # type: ignore
+                    num[i] -= 9  # type: ignore
+            sum += num[i]  # type: ignore
             logger.debug(f"Loop {i+1}: {num[i]}, {sum}")
-        
+
         out = (10 - (sum % 10)) % 10
         logger.debug(f"Output: {out}")
         return out
 
     @staticmethod
-    def combinations_range(sequence: list, *, min_len: int = 1, max_len: int = 0) -> List[tuple]:
+    def combinations_range(
+        sequence: list, *, min_len: int = 1, max_len: int = 0
+    ) -> List[tuple]:
         """
         Generate all combinations of a ``sequence`` from ``min_len`` to ``max_len``
 
@@ -305,17 +308,14 @@ class Generator:
         # Restrain
         if max_len < 1:
             max_len = len(sequence)
-        max_len = set_max(max_len, max_value=len(sequence))
-        min_len = set_min_max(min_len, min_value=1, max_value=max_len)
+        max_len = int(set_max(max_len, max_value=len(sequence)))
+        min_len = int(set_min_max(min_len, min_value=1, max_value=max_len))
         logger.debug(f"Combination range: [{min_len}, {max_len}]")
 
         # Return
         return list(
             chain.from_iterable(
-                [
-                    list(combinations(sequence, i))
-                    for i in range(min_len, max_len + 1)
-                ]
+                [list(combinations(sequence, i)) for i in range(min_len, max_len + 1)]
             )
         )
 
@@ -323,4 +323,4 @@ class Generator:
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    logger.setLevel(10) # DEBUG
+    logger.setLevel(10)  # DEBUG