absfuyu 4.1.1__py3-none-any.whl → 5.0.0__py3-none-any.whl

absfuyu/extensions/dev/__init__.py

@@ -1,244 +0,0 @@
-# type: ignore
-# flake8: noqa
-
-"""
-Absfuyu: Development
---------------------
-Some stuffs that are not ready to use yet.
-Use at your own risk, everything is subject to change
-
-Version: 2.0.0
-Date updated: 23/11/2023 (dd/mm/yyyy)
-"""
-
-# Module level
-###########################################################################
-__all__ = [
-    "password_check",
-    "fib",
-]
-
-
-# Library
-###########################################################################
-import base64
-import re
-from collections import deque
-from functools import lru_cache
-from typing import Dict, Final, List, NamedTuple
-
-
-# PASSWORD CHECKER
-def password_check(password: str) -> bool:
-    """
-    Verify the strength of 'password'.
-    Returns a dict indicating the wrong criteria.
-    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
-    """
-
-    # 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 = {
-        "password_ok": not any(
-            [  # overall result
-                length_error,
-                digit_error,
-                uppercase_error,
-                lowercase_error,
-                symbol_error,
-            ]
-        ),
-        "length_error": length_error,
-        "digit_error": digit_error,
-        "uppercase_error": uppercase_error,
-        "lowercase_error": lowercase_error,
-        "symbol_error": symbol_error,
-    }
-
-    return detail["password_ok"]
-
-
-# FIBONACCI WITH CACHE
-@lru_cache(maxsize=5)
-def fib(n: int) -> int:
-    """Fibonacci (recursive)"""
-    # max recursion is 484
-    if n < 2:
-        return n
-    return fib(n - 1) + fib(n - 2)
-
-
-# https://stackoverflow.com/questions/563022/whats-python-good-practice-for-importing-and-offering-optional-features
-def optional_import(module: str, name: str = None, package: str = None):
-    import importlib
-
-    try:
-        module = importlib.import_module(module)
-        return module if name is None else getattr(module, name)
-    except ImportError as e:
-        if package is None:
-            package = module
-        msg = f"install the '{package}' package to make use of this feature"
-        import_error = e
-
-        def _failed_import(*args):
-            raise ValueError(msg) from import_error
-
-        return _failed_import
-
-
-def load_toml_file(toml_file: str):
-    """
-    Load ``.toml`` file
-
-    :param toml_file: Path to ``.toml`` file
-    """
-    from sys import version_info as _python_version
-
-    if _python_version.minor < 11:
-        try:
-            import tomli as tomllib  # type: ignore
-        except ImportError:
-            raise ImportError("Please install tomli python package")
-        except:
-            raise SystemExit
-    else:
-        import tomllib
-
-    with open(toml_file, "rb") as file:
-        toml_data = tomllib.load(file)
-        return toml_data
-
-
-def get_sitemap(url: str):
-    import re
-
-    import requests
-
-    class Url(NamedTuple):
-        base: str
-        extra: str
-
-        def __str__(self) -> str:
-            return f"{self.base}{self.extra}"
-
-        def __repr__(self) -> str:
-            return f"{self.__class__.__name__}({self.base}{self.extra})"
-
-    # robots.txt
-    # sitemap.xml
-    if not url.endswith("/"):
-        url += "/"
-    pattern = re.compile(
-        r"([(http(s)?):\/\/(www\.)?a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b)([-a-zA-Z0-9@:%_\+.~#?&//=]*)",
-        re.IGNORECASE,
-    )
-    try:
-        url += "sitemap.xml"
-        res = requests.get(url).text
-    except:
-        # W.I.P
-        url += "robots.txt"
-        res = requests.get(url).text
-    regex = re.findall(pattern, res)
-    return list(map(Url._make, regex))
-
-
-from absfuyu.general import ClassBase
-
-
-class SimpleStrEncrypt(ClassBase):
-    """
-    Simple Encryption
-
-    Logic:
-    - Base64
-    - Shift characters
-    """
-
-    def __init__(self, times_to_base64_encode: int = 10, shift: int = 13) -> None:
-        """
-        :param times_to_base64_encode: How many time to base64 encode
-        :type times_to_base64_encode: int
-        :param shift: Shift characters to the right for how many position
-        :type shift: int
-        """
-        self.times_to_base64_encode = times_to_base64_encode
-        self.shift = shift
-
-    # Support
-    def _convert_table(self, text: str, shift: int) -> Dict[str, str]:
-        data = text
-
-        data = deque(sorted(list(set(data))))
-        translate = data.copy()
-        translate.rotate(shift)
-        convert_table = dict(zip(data, translate))
-
-        return convert_table
-
-    @staticmethod
-    def _use_convert_table(text: str, convert_table: Dict[str, str]) -> str:
-        """Use convert table"""
-        data = list(text)
-        for i, x in enumerate(data):
-            data[i] = convert_table[x]
-        return "".join(data)
-
-    @staticmethod
-    def _b64encode(text: str) -> str:
-        return base64.b64encode(text.encode()).decode()
-
-    @staticmethod
-    def _b64decode(text: str) -> str:
-        return base64.b64decode(text).decode()
-
-    # Main
-    def encode(self, text: str) -> str:
-        # Base64
-        data = text
-        for _ in range(self.times_to_base64_encode):
-            data = self._b64encode(data)
-
-        # Shift
-        convert_table = self._convert_table(data, self.shift)
-        return self._use_convert_table(data, convert_table)
-
-    def decode(self, text: str) -> str:
-        # Shift back
-        data = text
-        convert_table = self._convert_table(data, -self.shift)
-        data = self._use_convert_table(data, convert_table)
-
-        # Base64
-        for _ in range(self.times_to_base64_encode):
-            data = self._b64decode(data)
-
-        return data
-
-
-# testing
-CON_VAR: Final[List[str]] = ["a", "b"]  # Declare as final
-
-
-if __name__ == "__main__":
-    print(get_sitemap("https://kingdomality.com/"))

absfuyu/extensions/dev/password_hash.py

@@ -1,80 +0,0 @@
-# type: ignore
-# flake8: noqa
-
-# Library
-##############################################################
-import hashlib as __hash
-import os as __os
-from typing import Dict as __Dict
-from typing import NewType as __NewType
-from typing import TypeVar as __TypeVar
-from typing import Union as __Union
-
-# Define type
-##############################################################
-Password = __NewType("Password", str)
-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]]
-
-
-# Function
-##############################################################
-def password_hash(password: Password) -> Combo:
-    """
-    Generate hash for password
-    """
-    salt = __os.urandom(32)
-    key = __hash.pbkdf2_hmac(
-        hash_name="sha256",
-        password=password.encode("utf-8"),
-        salt=salt,
-        iterations=100000,
-    )
-    out = {
-        "salt": salt,
-        "key": key,
-    }
-    return out
-
-
-def password_hash_check(
-    password: Password,
-    combo: Combo,
-) -> bool:
-    """
-    Compare hashes between 2 passwords
-    """
-    if "salt" in combo and "key" in combo:
-        salt = combo["salt"]
-        compare_key = combo["key"]
-    else:
-        return None
-
-    key = __hash.pbkdf2_hmac(
-        hash_name="sha256",
-        password=password.encode("utf-8"),
-        salt=salt,
-        iterations=100000,
-    )
-
-    if key == compare_key:
-        return True
-    else:
-        return False
-
-
-def tj():
-    import json
-
-    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())

absfuyu/extensions/dev/passwordlib.py

@@ -1,258 +0,0 @@
-# type: ignore
-# flake8: noqa
-
-"""
-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, Optional
-
-from absfuyu_res import DATA
-
-from absfuyu.general.data_extension import DictExt, Text
-from absfuyu.general.generator import Charset, Generator
-from absfuyu.logger import logger
-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(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/project_starter.py

@@ -1,60 +0,0 @@
-# type: ignore
-# flake8: noqa
-
-"""
-Absfuyu: Project starter
-------------------------
-
-Version: 1.0.0dev1
-Date updated: 01/12/2023 (dd/mm/yyyy)
-"""
-
-# Module level
-###########################################################################
-__all__ = ["get_parser"]
-
-
-# Library
-###########################################################################
-from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
-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