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

absfuyu/tools/keygen.py

@@ -5,16 +5,13 @@ Mod7 product key generator (90's)
 
 This is for educational and informative purposes only.
 
-Version: 2.0.1
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 2.0.2
+Date updated: 05/04/2024 (dd/mm/yyyy)
 """
 
-
 # Module level
 ###########################################################################
-__all__ = [
-    "Keygen"
-]
+__all__ = ["Keygen"]
 
 
 # Library
@@ -26,88 +23,84 @@ import random
 ###########################################################################
 class Keygen:
     """Key generator"""
+
     @staticmethod
     def _is_mod7(text: str) -> bool:
         """
         Check if sum of elements in a string is divisible by 7
 
-        text: number in str type to check
+        :param text: number in str type to check
         """
-        text = str(text) # Safety convert
+        text = str(text)  # Safety convert
         try:
             res = sum(map(int, text)) % 7
             # logger.debug(f"Sum value: {res}")
             return res == 0
-        except:
-            raise ValueError("Invalid string")
-    
+        except Exception:
+            raise ValueError("Invalid string")  # noqa: B904
+
     @staticmethod
-    def _mod7_gen(
-            num_of_digits: int,
-            *,
-            fillchar: str = "0"
-        ) -> str:
+    def _mod7_gen(num_of_digits: int, *, fillchar: str = "0") -> str:
         """
         Generate a number with desired length that is divisible by 7
 
-        Parameters:
-        ---
+        Parameters
+        ----------
         num_of_digits : int
             Length of number
 
         fillchar : str
             filled character when `len(generated number)` < `num_of_digits`
-        
-        Return:
-        ---
+
+        Returns
+        -------
         str:
             Mod7 number
         """
-        
+
         # Init
         mod7_num: int = 0
-        
+
         # Conditions
-        max_value = 10**num_of_digits-1
+        max_value = 10**num_of_digits - 1
         mod7_valid = False
-        invalid_digits = [0,8,9] # Invalid last digit
-        
+        invalid_digits = [0, 8, 9]  # Invalid last digit
+
         # Loop
         while not mod7_valid:
             # Gen num
             mod7_num = random.randint(0, max_value)
-            
+
             # Check last digit
             if int(str(mod7_num)[-1]) in invalid_digits:
                 continue
-            
+
             # Check divide by 7
-            if __class__._is_mod7(mod7_num):
+            if __class__._is_mod7(mod7_num):  # type: ignore
                 mod7_valid = True
-        
+
         # Output
         return str(mod7_num).rjust(num_of_digits, fillchar)
 
-
     @staticmethod
     def mod7_cd_key(fast: bool = False) -> str:
         """
         CD Key generator
 
-        Format: ``XXX-XXXXXXX``                              
-        
+        Format: ``XXX-XXXXXXX``
+
         Rules:
-        
+
         - Last seven digits must add to be divisible by ``7``
         - First 3 digits cannot be ``333``, ``444``,..., ``999``
         - Last digit of last seven digits cannot be ``0``, ``8`` or ``9``
-        
+
         Parameters
         ----------
         fast : bool
-            Use pre-generated key 
+            Use pre-generated key
             (Default: ``False``)
-        
+
         Returns
         -------
         str:
@@ -122,15 +115,15 @@ class Keygen:
         part1_valid = False
         part1_not_valid_digits = [333, 444, 555, 666, 777, 888]
         part1: str = ""
-        while not part1_valid: # Loop check
-            part1_num = random.randint(0, 998) # Gen random int from 0 to 998
+        while not part1_valid:  # Loop check
+            part1_num = random.randint(0, 998)  # Gen random int from 0 to 998
             # part1_num = random.randint(100,300) # or just use this
             if part1_num not in part1_not_valid_digits:
-                part1 = str(part1_num).rjust(3, "0") # Convert into string
-                part1_valid = True # Break loop
+                part1 = str(part1_num).rjust(3, "0")  # Convert into string
+                part1_valid = True  # Break loop
 
         # PART 02
-        part2 = __class__._mod7_gen(num_of_digits=7)
+        part2 = __class__._mod7_gen(num_of_digits=7)  # type: ignore
 
         # OUTPUT
         return f"{part1}-{part2}"
@@ -141,42 +134,44 @@ class Keygen:
         11-digit CD Key generator
 
         Format: ``XXXX-XXXXXXX``
-        
+
         - ``XXXX``: Can be anything from ``0001`` to ``9991``. The last digit must be 3rd digit + ``1`` or ``2``. When the result is > ``9``, it overflows to ``0`` or ``1``.
         - ``XXXXXXX``: Same as CD Key
-        
+
         Parameters
         ----------
         fast : bool
-            Use pre-generated key 
+            Use pre-generated key
             (Default: ``False``)
-        
+
         Returns
         -------
         str:
             Mod7 Key
         """
-        
+
         # Fast mode: pre-generated key
         if fast:
             return "0001-0000007"
-        
+
         # PART 01
         part1_valid = False
         part1: str = ""
         while not part1_valid:
-            part1_1_num = random.randint(0, 999) # Random 3-digit number
-            last_digit_choice = [1, 2] # Choice for last digit
-            part1_2_num = int(str(part1_1_num)[-1]) + random.choice(last_digit_choice) # Make last digit
-            if part1_2_num > 9: # Check condition then overflow
-                part1_2_num = str(part1_2_num)[-1]
-            part1_str = f"{part1_1_num}{part1_2_num}" # Concat string
-            if int(part1_str) < 9991: # Check if < 9991
+            part1_1_num = random.randint(0, 999)  # Random 3-digit number
+            last_digit_choice = [1, 2]  # Choice for last digit
+            part1_2_num = int(str(part1_1_num)[-1]) + random.choice(
+                last_digit_choice
+            )  # Make last digit
+            if part1_2_num > 9:  # Check condition then overflow
+                part1_2_num = int(str(part1_2_num)[-1])
+            part1_str = f"{part1_1_num}{part1_2_num}"  # Concat string
+            if int(part1_str) < 9991:  # Check if < 9991
                 part1 = part1_str.rjust(4, "0")
                 part1_valid = True
 
         # PART 02
-        part2 = __class__._mod7_gen(num_of_digits=7)
+        part2 = __class__._mod7_gen(num_of_digits=7)  # type: ignore
 
         # OUTPUT
         return f"{part1}-{part2}"
@@ -196,19 +191,19 @@ class Keygen:
         Parameters
         ----------
         fast : bool
-            Use pre-generated key 
+            Use pre-generated key
             (Default: ``False``)
-        
+
         Returns
         -------
         str:
             Mod7 Key
         """
-        
+
         # Fast mode: pre-generated key
         if fast:
             return "00100-OEM-0000007-00000"
-        
+
         # PART ABC
         abc_part = str(random.randint(1, 365)).rjust(3, "0")
 
@@ -219,7 +214,7 @@ class Keygen:
         y_part = random.choice(year_choice)
 
         # NUM PART
-        num_part = __class__._mod7_gen(num_of_digits=6)
+        num_part = __class__._mod7_gen(num_of_digits=6)  # type: ignore
 
         # NUM PART 02
         num_part_2 = str(random.randint(0, 99999)).rjust(5, "0")
@@ -235,18 +230,18 @@ class Keygen:
         Parameters
         ----------
         fast : bool
-            Use pre-generated key 
+            Use pre-generated key
             (Default: ``False``)
-        
+
         Returns
         -------
         dict:
             Mod7 Key combo
         """
         out = {
-            "CD Key": __class__.mod7_cd_key(fast=fast),
-            "OEM Key": __class__.mod7_oem_key(fast=fast),
-            "11-digit Key": __class__.mod7_11_digit_key(fast=fast)
+            "CD Key": __class__.mod7_cd_key(fast=fast),  # type: ignore
+            "OEM Key": __class__.mod7_oem_key(fast=fast),  # type: ignore
+            "11-digit Key": __class__.mod7_11_digit_key(fast=fast),  # type: ignore
         }
         return out
 
@@ -255,4 +250,4 @@ class Keygen:
 ###########################################################################
 if __name__ == "__main__":
     test = Keygen()
-    print(test.mod7_combo())
+    print(test.mod7_combo())

absfuyu/tools/obfuscator.py

@@ -3,16 +3,13 @@ Absfuyu: Obfuscator
 -------------------
 Obfuscate code
 
-Version: 2.0.1
-Date updated: 26/11/2023 (dd/mm/yyyy)
+Version: 2.0.2
+Date updated: 05/04/2024 (dd/mm/yyyy)
 """
 
-
 # Module level
 ###########################################################################
-__all__ = [
-    "Obfuscator"
-]
+__all__ = ["Obfuscator"]
 
 
 # Library
@@ -22,9 +19,10 @@ import codecs
 import random
 import zlib
 
-from absfuyu.logger import logger
-from absfuyu.general.generator import Generator as gen, Charset
 from absfuyu.general.data_extension import Text
+from absfuyu.general.generator import Charset
+from absfuyu.general.generator import Generator as gen
+from absfuyu.logger import logger
 
 
 # Class
@@ -33,17 +31,19 @@ class ObfuscatorLibraryList:
     BASE64_ONLY = ["base64"]
     FULL = ["base64", "codecs", "zlib"]
 
+
 class Obfuscator:
     """Obfuscate code"""
+
     def __init__(
-            self,
-            code: str,
-            *,
-            base64_only: bool = False,
-            split_every: int = 60,
-            variable_length: int = 12,
-            fake_data: bool = False
-        ) -> None:
+        self,
+        code: str,
+        *,
+        base64_only: bool = False,
+        split_every: int = 60,
+        variable_length: int = 12,
+        fake_data: bool = False,
+    ) -> None:
         """
         code: Code text
         base64_only: False: base64, compress, rot13 (default) | True: encode in base64 form only
@@ -62,17 +62,18 @@ class Obfuscator:
         self._splited_variable_length = self.variable_length
         self._decode_variable_length = self.variable_length + 3
         # logger.debug("Class initiated.")
-    
+
     def __str__(self) -> str:
         # temp = self.__dict__
         temp = {
             "base_code": "...",
             "base64_only": self.base64_only,
-            "split_every_length": self.split_every_length, 
+            "split_every_length": self.split_every_length,
             "variable_length": self.variable_length,
-            "fake_data": self.fake_data
+            "fake_data": self.fake_data,
         }
         return f"{self.__class__.__name__}({temp})"
+
     def __repr__(self) -> str:
         return self.__str__()
 
@@ -88,7 +89,6 @@ class Obfuscator:
         output = f"exec(bytes.fromhex('{newcode}').decode('utf-8'))"
         return output
 
-
     def _obfuscate(self) -> str:
         """
         Convert multiple lines of code through multiple transformation
@@ -103,13 +103,13 @@ class Obfuscator:
         else:
             compressed_data = zlib.compress(b64_encode)
             # log_debug(compressed_data)
-            logger.debug(f"Compressed data: {compressed_data}")
+            logger.debug(f"Compressed data: {compressed_data}")  # type: ignore
             b64_encode_2 = base64.b64encode(compressed_data)
             # log_debug(b64_encode_2)
-            logger.debug(f"Base64 encode 2: {b64_encode_2}")
+            logger.debug(f"Base64 encode 2: {b64_encode_2}")  # type: ignore
             caesar_data = codecs.encode(b64_encode_2.decode(), "rot_13")
             output = caesar_data
-        
+
         logger.debug(f"Output: {output}")
         logger.debug("Code encoded.")
         return output
@@ -118,7 +118,7 @@ class Obfuscator:
     def _convert_to_base64_decode(text: str, raw: bool = False) -> str:
         """
         Convert text into base64 and then return a code that decode that base64 code
-        
+
         text: Code that need to convert
         raw: Return hex form only
         """
@@ -131,45 +131,47 @@ class Obfuscator:
             return hex
         return out
 
-    def _obfuscate_out(self) -> list:
+    def _obfuscate_out(self) -> list:  # type: ignore
         """
         Convert multiple lines of code through multiple transformation
         (base64 -> compress -> base64 -> caesar (13))
-        
+
         Then return a list (obfuscated code) that can
         be print or export into .txt file
-        """        
+        """
         # Obfuscated code
         input_str = Text(self._obfuscate())
-        
+
         # Generate output
         output = []
 
         # Import library
-        library_list = ObfuscatorLibraryList.BASE64_ONLY if self.base64_only else ObfuscatorLibraryList.FULL
+        library_list = (
+            ObfuscatorLibraryList.BASE64_ONLY
+            if self.base64_only
+            else ObfuscatorLibraryList.FULL
+        )
         temp = [f"import {lib}" for lib in library_list]
         logger.debug(f"Lib: {temp}")
-        lib_hex = Text("\n".join(temp)).to_hex() # Convert to hex
-        output.append(f"exec('{lib_hex}')")        
+        lib_hex = Text("\n".join(temp)).to_hex()  # Convert to hex
+        output.append(f"exec('{lib_hex}')")
         logger.debug(f"Current output (import library): {output}")
 
         # Append divided long text list
         input_list = input_str.divide_with_variable(
             split_size=self.split_every_length,
-            split_var_len=self._splited_variable_length
+            split_var_len=self._splited_variable_length,
         )
-        encoded_str = input_list[-1] # Main var name that will later be used
-        output.extend(input_list[:-1]) # Append list minus the last element
+        encoded_str = input_list[-1]  # Main var name that will later be used
+        output.extend(input_list[:-1])  # Append list minus the last element
         logger.debug(f"Current output (encoded code): {output}")
 
         # Decode: encoded_str
         dc_name_lst = gen.generate_string(
-            charset=Charset.ALPHABET,
-            size=self._decode_variable_length,
-            times=3
+            charset=Charset.ALPHABET, size=self._decode_variable_length, times=3
         )
-        encode_codec = "rot_13" #full
-        if not self.base64_only: #full
+        encode_codec = "rot_13"  # full
+        if not self.base64_only:  # full
             hex_0 = self._convert_to_base64_decode(encode_codec)
             output.append(f"{dc_name_lst[0]}={hex_0}")
         hex_1 = Text("<string>").to_hex()
@@ -178,13 +180,13 @@ class Obfuscator:
         output.append(f"{dc_name_lst[2]}='{hex_2}'")
         logger.debug(f"Current output (decode variables): {output}")
 
-        if self.base64_only: #b64
+        if self.base64_only:  # b64
             pre_hex = (
                 f"eval(compile(base64."
                 f"b64decode({encoded_str}),{dc_name_lst[1]},"
                 f"{dc_name_lst[2]}))"
             )
-        else: #full
+        else:  # full
             pre_hex = (
                 f"eval(compile(base64."
                 f"b64decode(zlib.decompress(base64."
@@ -202,20 +204,22 @@ class Obfuscator:
                 charset=Charset.DEFAULT,
                 size=len(input_str),
                 times=1,
-                string_type_if_1=True
-            ) # Generate fake data with len of original data
-            f2 = Text(f1).divide_with_variable(self.split_every_length, self._splited_variable_length)
+                string_type_if_1=True,
+            )  # Generate fake data with len of original data
+            f2 = Text(f1).divide_with_variable(
+                self.split_every_length, self._splited_variable_length
+            )
             output.extend(f2[:-1])
-            
+
             # Random data
             bait_lst = gen.generate_string(
-                charset=Charset.ALPHABET,
-                size=self._splited_variable_length,
-                times=25
+                charset=Charset.ALPHABET, size=self._splited_variable_length, times=25
             )
             for x in bait_lst:
-                output.append(f"{x}='{gen.generate_string(charset=Charset.DEFAULT,size=self.split_every_length,times=1,string_type_if_1=True)}'")
-            
+                output.append(
+                    f"{x}='{gen.generate_string(charset=Charset.DEFAULT,size=self.split_every_length,times=1,string_type_if_1=True)}'"
+                )
+
             random_eval_text = str(random.randint(1, 100))
             for _ in range(random.randint(10, 50)):
                 random_eval_text += f"+{random.randint(1, 100)}"
@@ -224,11 +228,11 @@ class Obfuscator:
 
         logger.debug("Code obfuscated.")
         return output
-    
+
     def obfuscate(self) -> str:
         """
         Obfuscate code
-        
+
         :returns: Obfuscated code
         :rtype: str
         """
@@ -241,4 +245,4 @@ if __name__ == "__main__":
     logger.setLevel(10)
     code = "print('Hello World')"
     test = Obfuscator(code, fake_data=True)
-    print(test.obfuscate())
+    print(test.obfuscate())

absfuyu/tools/stats.py

@@ -1,18 +1,16 @@
+# flake8: noqa
 """
 Absfuyu: Stats
 --------------
-List's stats
+List's stats (soon will be deprecated)
 
 Version: 2.0.3
 Date updated: 26/11/2023 (dd/mm/yyyy)
 """
 
-
 # Module level
 ###########################################################################
-__all__ = [
-    "ListStats"
-]
+__all__ = ["ListStats"]
 
 
 # Library
@@ -28,6 +26,7 @@ from absfuyu.logger import logger
 ###########################################################################
 class ListStats(List[Union[int, float]]):
     """Stats"""
+
     def mean(self) -> float:
         """
         Mean/Average
@@ -45,12 +44,12 @@ class ListStats(List[Union[int, float]]):
         3.5
         """
         s = sum(self)
-        return s/len(self)
+        return s / len(self)
 
     def median(self) -> Union[int, float]:
         """
         Median/Middle
-        
+
         Returns
         -------
         int | float
@@ -76,9 +75,9 @@ class ListStats(List[Union[int, float]]):
     def mode(self) -> List[Union[int, float]]:
         """
         Mode:
-        
+
             The Mode value is the value that appears the most number of times
-        
+
         Returns
         -------
         list[int | float]
@@ -93,20 +92,20 @@ class ListStats(List[Union[int, float]]):
         """
         lst = self
         frequency = ListExt(lst).freq()
-        
-        max_val = max(frequency.values())
+
+        max_val = max(frequency.values())  # type: ignore
         keys = []
-        
-        for k, v in frequency.items():
+
+        for k, v in frequency.items():  # type: ignore
             if v == max_val:
                 keys.append(k)
-        
+
         return keys
 
     def var(self) -> float:
         """
         Variance
-        
+
         Returns
         -------
         float
@@ -121,14 +120,14 @@ class ListStats(List[Union[int, float]]):
         """
         lst = self
         MEAN = self.mean()
-        v = [(x-MEAN)**2 for x in lst]
-        out = sum(v)/len(v)
+        v = [(x - MEAN) ** 2 for x in lst]
+        out = sum(v) / len(v)
         return out
 
     def std(self) -> float:
         """
         Standard deviation
-        
+
         Returns
         -------
         float
@@ -151,9 +150,9 @@ class ListStats(List[Union[int, float]]):
         Parameters
         ----------
         percent : int
-            Which percentile 
+            Which percentile
             (Default: ``50``)
-        
+
         Returns
         -------
         int | float
@@ -175,7 +174,7 @@ class ListStats(List[Union[int, float]]):
     def summary(self):
         """
         Quick summary of data
-        
+
         Returns
         -------
         dict
@@ -212,7 +211,7 @@ class ListStats(List[Union[int, float]]):
                 "1st Quartile": self.percentile(25),
                 "2nd Quartile": self.percentile(50),
                 "3rd Quartile": self.percentile(75),
-            }
+            },
         }
         return output
 
@@ -222,5 +221,6 @@ class ListStats(List[Union[int, float]]):
 if __name__ == "__main__":
     logger.setLevel(10)
     from rich import print
-    test = ListStats([1,8,9,2,3,4,4])
-    print(test.summary())
+
+    test = ListStats([1, 8, 9, 2, 3, 4, 4])
+    print(test.summary())