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

absfuyu/extensions/dev/password_hash.py

@@ -8,7 +8,6 @@ from typing import Union as __Union
 from typing import NewType as __NewType
 
 
-
 # Define type
 ##############################################################
 Password = __NewType("Password", str)
@@ -16,7 +15,7 @@ Salt = __NewType("Salt", str)
 Key = __NewType("Key", str)
 Salt_V = __NewType("Salt_V", bytes)
 Key_V = __NewType("Key_V", bytes)
-Combo = __Dict[__Union[Salt,Key], __Union[Salt_V,Key_V]]
+Combo = __Dict[__Union[Salt, Key], __Union[Salt_V, Key_V]]
 
 
 # Function
@@ -38,10 +37,11 @@ def password_hash(password: Password) -> Combo:
     }
     return out
 
+
 def password_hash_check(
-        password: Password,
-        combo: Combo,
-    ) -> bool:
+    password: Password,
+    combo: Combo,
+) -> bool:
     """
     Compare hashes between 2 passwords
     """
@@ -50,7 +50,7 @@ def password_hash_check(
         compare_key = combo["key"]
     else:
         return None
-    
+
     key = __hash.pbkdf2_hmac(
         hash_name="sha256",
         password=password.encode("utf-8"),
@@ -58,7 +58,7 @@ def password_hash_check(
         iterations=100000,
     )
 
-    if key==compare_key:
+    if key == compare_key:
         return True
     else:
         return False
@@ -66,12 +66,13 @@ def password_hash_check(
 
 def tj():
     import json
-    combo=password_hash("lmao")
-    for k,v in combo.items():
+
+    combo = password_hash("lmao")
+    for k, v in combo.items():
         combo[k] = str(v)
     j = json.dumps(combo, indent=4)
     return j
 
 
 if __name__ == "__main__":
-    print(tj())
+    print(tj())

absfuyu/extensions/dev/passwordlib.py

@@ -0,0 +1,256 @@
+"""
+Absfuyu: Passwordlib
+--------------------
+Password library
+
+Version: 1.0.0dev1
+Date updated: 30/11/2023 (dd/mm/yyyy)
+"""
+
+
+# Library
+###########################################################################
+# from collections import namedtuple
+import hashlib
+import os
+import random
+import re
+from typing import List, Dict, Optional, Union
+
+from absfuyu_res import DATA
+
+from absfuyu.logger import logger
+from absfuyu.general.data_extension import DictExt, Text
+from absfuyu.general.generator import Generator, Charset
+from absfuyu.util import set_min
+from absfuyu.util.pkl import Pickler
+
+
+# Function
+###########################################################################
+def password_check(password: str) -> bool:
+    """
+    Verify the strength of ``password``.
+    A password is considered strong if:
+
+    - 8 characters length or more
+    - 1 digit or more
+    - 1 symbol or more
+    - 1 uppercase letter or more
+    - 1 lowercase letter or more
+
+    :param password: Password want to be checked
+    :type password: str
+    :rtype: bool
+    """
+
+    # calculating the length
+    length_error = len(password) < 8
+
+    # searching for digits
+    digit_error = re.search(r"\d", password) is None
+
+    # searching for uppercase
+    uppercase_error = re.search(r"[A-Z]", password) is None
+
+    # searching for lowercase
+    lowercase_error = re.search(r"[a-z]", password) is None
+
+    # searching for symbols
+    symbols = re.compile(r"[ !#$%&'()*+,-./[\\\]^_`{|}~" + r'"]')
+    symbol_error = symbols.search(password) is None
+
+    detail = {
+        "length_error": length_error,
+        "digit_error": digit_error,
+        "uppercase_error": uppercase_error,
+        "lowercase_error": lowercase_error,
+        "symbol_error": symbol_error,
+    }
+    logger.debug(f"Password error summary: {detail}")
+
+    return not any(
+        [
+            length_error,
+            digit_error,
+            uppercase_error,
+            lowercase_error,
+            symbol_error,
+        ]
+    )
+
+
+# Class
+###########################################################################
+class Password:
+    """Password"""
+
+    def __init__(self) -> None:
+        """doc_string"""
+        self.password: str = None
+        self._words: List[str] = Pickler.load(DATA.PASSWORDLIB)
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def password_hash(self):
+        """
+        Generate hash for password
+        """
+        salt = os.urandom(32)
+        key = hashlib.pbkdf2_hmac(
+            hash_name="sha256",
+            password=self.password.encode("utf-8"),
+            salt=salt,
+            iterations=100000,
+        )
+        out = {
+            "salt": salt,
+            "key": key,
+        }
+        return out
+
+    @staticmethod
+    def password_check(password: str):
+        data = Text(password).analyze()
+        data.__setitem__("length", len(password))
+        data = DictExt(data).apply(lambda x: True if x > 0 else False)
+        return data
+
+    @property
+    def words(self) -> List[str]:
+        """
+        Word list to generate passphrase
+
+        :rtype: list[str]
+        """
+        return self._words
+
+    # Password generator
+    @staticmethod
+    def generate_password(
+        length: int = 8,
+        include_uppercase: bool = True,
+        include_number: bool = True,
+        include_special: bool = True,
+    ) -> str:
+        r"""
+        Generate a random password
+
+        Parameters
+        ----------
+        length : int
+            | Length of the password.
+            | Minimum value: ``8``
+            | (Default: ``8``)
+
+        include_uppercase : bool
+            Include uppercase character in the password (Default: ``True``)
+
+        include_number : bool
+            Include digit character in the password (Default: ``True``)
+
+        include_special : bool
+            Include special character in the password (Default: ``True``)
+
+        Returns
+        -------
+        str
+            Generated password
+
+
+        Example:
+        --------
+        >>> Password.generate_password()
+        [T&b@mq2
+        """
+        charset = Charset.LOWERCASE
+        check = 0
+
+        if include_uppercase:
+            charset += Charset.UPPERCASE
+            check += 1
+
+        if include_number:
+            charset += Charset.DIGIT
+            check += 1
+
+        if include_special:
+            charset += r"[ !#$%&'()*+,-./[\\\]^_`{|}~" + r'"]'
+            check += 1
+
+        while True:
+            pwd = Generator.generate_string(
+                charset=charset,
+                size=set_min(length, min_value=8),
+                times=1,
+                string_type_if_1=True,
+            )
+
+            analyze = Text(pwd).analyze()  # Count each type of char
+
+            s = sum([1 for x in analyze.values() if x > 0])
+            if s > check:  # Break loop if each type of char has atleast 1
+                break
+        return pwd
+
+    def generate_passphrase(
+        self,
+        num_of_blocks: int = 5,
+        block_divider: Optional[str] = None,
+        first_letter_cap: bool = True,
+        include_number: bool = True,
+    ) -> str:
+        """
+        Generate a random passphrase
+
+        Parameters
+        ----------
+        num_of_blocks : int
+            Number of word used (Default: ``5``)
+
+        block_divider : str
+            Character symbol that between each word (Default: ``"-"``)
+
+        first_letter_cap : bool
+            Capitalize first character of each word (Default: ``True``)
+
+        include_number : bool
+            Add number to the end of each word (Default: ``True``)
+
+        Returns
+        -------
+        str
+            Generated passphrase
+
+
+        Example:
+        --------
+        >>> print(Password().generate_passphrase())
+        Myomectomies7-Sully4-Torpedomen7-Netful2-Begaud8
+        """
+
+        def convert_func(value: str):
+            if first_letter_cap:
+                value = value.title()
+            if include_number:
+                value += str(random.choice(range(0, 10)))
+            return value
+
+        if not block_divider:
+            block_divider = "-"
+
+        return block_divider.join(
+            [convert_func(random.choice(self.words)) for _ in range(num_of_blocks)]
+        )
+
+
+# Run
+###########################################################################
+if __name__ == "__main__":
+    logger.setLevel(10)
+    # print(os.urandom(32))
+    print(Password.password_check(Password.generate_password()))

absfuyu/extensions/dev/pkglib.py

@@ -1,51 +1,74 @@
-from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
-from typing import Dict, List, Union
+from typing import Dict, List
 
 # json
 __all_lib = {
     "native": [
-        "os","random","string","subprocess","typing","hashlib",
-        "datetime","json","sys","math","base64","codecs",
-        "zlib","inspect","functools","tracemalloc", "re",
-        "collections", "urllib", "time",
+        "os",
+        "random",
+        "string",
+        "subprocess",
+        "typing",
+        "hashlib",
+        "datetime",
+        "json",
+        "sys",
+        "math",
+        "base64",
+        "codecs",
+        "zlib",
+        "inspect",
+        "functools",
+        "tracemalloc",
+        "re",
+        "collections",
+        "urllib",
+        "time",
+        "pathlib",
+        "itertools",
+        "argparse",
+        "operator",
+        "shutil",
     ],
     "external": [
-        "rich","click","colorama","requests","numpy","pandas",
-        "matplotlib","LunarCalendar",
+        "rich",
+        "click",
+        "colorama",
+        "requests",
+        "numpy",
+        "pandas",
+        "matplotlib",
+        "absfuyu_res",
+        "importlib_resources",
     ],
     "dev-only": [
-        "twine", "virtualenv", "setuptools", "wheel",
-        "autoimport", "black", "pytest", "tox", "build",
-        "pipx",
-    ],
-    "unused": [
-        "sortedcontainers", "tomli", "pyyaml",
-    ],
-    "future": [
-        "scikit-learn", "opencv-python",
+        "twine",
+        "black",
+        "pytest",
+        "tox",
+        "build",
+        "coverage",
     ],
 }
 
 LibraryDict = Dict[str, List[str]]
 
+
 def show_lib_from_json(
-        lib_dict: LibraryDict,
-        hidden: bool = False,
-        to_json: bool = True
-    ) -> str:
+    lib_dict: LibraryDict, hidden: bool = False, to_json: bool = True
+) -> str:
     """
     Show libraries
-    
+
     lib_dict: a dict that converted from jso
     hidden: import as __[lib name]
     to_json: save as json format
     """
 
-    catergory = [x for x in lib_dict.keys()] # get keys
-    libs = [x for x in lib_dict.values()] # get values
+    catergory = [x for x in lib_dict.keys()]  # get keys
+    libs = [x for x in lib_dict.values()]  # get values
 
-    lib_import = [] # New list
-    for lib_list in libs: # Take each lib list in a list of lib list
+    lib_import = []  # New list
+    for lib_list in libs:  # Take each lib list in a list of lib list
         temp = []
         for item in sorted(list(set(lib_list))):
             if hidden:
@@ -59,44 +82,17 @@ def show_lib_from_json(
 
     if to_json:
         import json
+
         return str(json.dumps(new_lib, indent=4))
     else:
         out_text = ""
         for idx, val in enumerate(catergory):
             out_text += f"# {val} libs\n"
             for x in lib_import[idx]:
-                out_text += x+"\n"
+                out_text += x + "\n"
             out_text += "\n"
         return out_text
 
 
-# idk why i add arg parser here *shrug*
-def get_parser(
-        name: Union[str, None] = None,
-        description: Union[str, None] = None,
-        epilog: Union[str, None] = None,
-        *,
-        version: str = "",
-        add_help: bool = True,
-    ) -> ArgumentParser:
-    arg_parser = ArgumentParser(
-        prog=name,
-        description=description,
-        epilog=epilog,
-        add_help=add_help,
-        formatter_class=ArgumentDefaultsHelpFormatter,
-        # allow_abbrev=False, # Disable long options recognize
-        # exit_on_error=True
-    )
-    arg_parser.add_argument("--version", action="version",
-                            version=f"%(prog)s {version}")
-    _ll_val = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
-    arg_parser.add_argument(
-        "--log-level",
-        metavar="LOG_LEVEL",
-        dest="log_level",
-        choices=_ll_val,
-        default="INFO",
-        help=f"Log level: {_ll_val}"
-    )
-    return arg_parser
+if __name__ == "__main__":
+    print(show_lib_from_json(__all_lib, 0, 0))

absfuyu/extensions/dev/project_starter.py

@@ -0,0 +1,58 @@
+"""
+Absfuyu: Project starter
+------------------------
+
+Version: 1.0.0dev1
+Date updated: 01/12/2023 (dd/mm/yyyy)
+"""
+
+
+# Module level
+###########################################################################
+__all__ = ["get_parser"]
+
+
+# Library
+###########################################################################
+from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
+from typing import Optional
+
+
+# Function
+###########################################################################
+def get_parser(
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    epilog: Optional[str] = None,
+    *,
+    version: str = "",
+    add_help: bool = True,
+) -> ArgumentParser:
+    arg_parser = ArgumentParser(
+        prog=name,
+        description=description,
+        epilog=epilog,
+        add_help=add_help,
+        formatter_class=ArgumentDefaultsHelpFormatter,
+        # allow_abbrev=False, # Disable long options recognize
+        # exit_on_error=True
+    )
+    arg_parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {version}"
+    )
+    _ll_val = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+    arg_parser.add_argument(
+        "--log-level",
+        metavar="LOG_LEVEL",
+        dest="log_level",
+        choices=_ll_val,
+        default="INFO",
+        help=f"Log level: {_ll_val}",
+    )
+    return arg_parser
+
+
+# Run
+###########################################################################
+if __name__ == "__main__":
+    pass

absfuyu/extensions/dev/shutdownizer.py

@@ -0,0 +1,8 @@
+"""
+Absfuyu: Shutdownizer
+---------------------
+This shutdowns
+
+Version: 1.0.0dev
+Date updated: 27/11/2023 (dd/mm/yyyy)
+"""