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

absfuyu/tools/passwordlib.py

@@ -0,0 +1,330 @@
+"""
+Absfuyu: Passwordlib
+--------------------
+Password library
+
+Version: 5.0.0
+Date updated: 19/02/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["PasswordGenerator", "TOTP"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+import hashlib
+import os
+import random
+import re
+from typing import ClassVar, Literal, NamedTuple
+from urllib.parse import quote, urlencode
+
+from absfuyu.core import BaseClass, deprecated, versionadded
+from absfuyu.dxt import DictExt, Text
+from absfuyu.general.generator import Charset, Generator
+from absfuyu.logger import logger
+from absfuyu.pkg_data import DataList, DataLoader
+from absfuyu.util import set_min
+
+
+# Function
+# ---------------------------------------------------------------------------
+@deprecated("5.0.0")
+@versionadded("4.2.0")
+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 PasswordHash(NamedTuple):
+    salt: bytes
+    key: bytes
+
+
+@versionadded("4.2.0")
+class PasswordGenerator(BaseClass):
+    """Password Generator"""
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+    @staticmethod
+    def password_hash(password: str) -> PasswordHash:
+        """
+        Generate hash for password
+        """
+        salt = os.urandom(32)
+        key = hashlib.pbkdf2_hmac(
+            hash_name="sha256",
+            password=password.encode("utf-8"),
+            salt=salt,
+            iterations=100000,
+        )
+        out = PasswordHash(salt, key)
+        return out
+
+    @staticmethod
+    def password_check(password: str) -> dict:
+        """Check password's characteristic"""
+        data = Text(password).analyze()
+        data = DictExt(data).apply(lambda x: True if x > 0 else False)  # type: ignore
+        data.__setitem__("length", len(password))
+        return dict(data)
+
+    # 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"[!#$%&'()*+,-./]^_`{|}~\""
+            check += 1
+
+        while True:
+            pwd = Generator.generate_string(
+                charset=charset,
+                size=set_min(length, min_value=8),  # type: ignore
+                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])  # type: ignore
+            if s > check:  # Break loop if each type of char has atleast 1
+                break
+        return pwd  # type: ignore
+
+    @staticmethod
+    def generate_passphrase(
+        num_of_blocks: int = 5,
+        block_divider: str | None = None,
+        first_letter_cap: bool = True,
+        include_number: bool = True,
+        *,
+        custom_word_list: list[str] | None = None,
+    ) -> 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``)
+
+        custom_word_list : list[str] | None
+            Custom word list for passphrase generation, by default uses a list of 360K+ words
+
+        Returns
+        -------
+        str
+            Generated passphrase
+
+
+        Example:
+        --------
+        >>> print(Password().generate_passphrase())
+        Myomectomies7-Sully4-Torpedomen7-Netful2-Begaud8
+        """
+        words: list[str] = (
+            DataLoader(DataList.PASSWORDLIB).load().decode().split(",")
+            if not custom_word_list
+            else custom_word_list
+        )
+
+        if block_divider is None:
+            block_divider = "-"
+
+        dat = [random.choice(words) for _ in range(num_of_blocks)]
+
+        if first_letter_cap:
+            dat = list(map(lambda x: x.title(), dat))
+
+        if include_number:
+            idx = random.choice(range(num_of_blocks))
+            dat[idx] += str(random.choice(range(10)))
+
+        return block_divider.join(dat)
+
+
+@versionadded("5.0.0")
+class TOTP(BaseClass):
+    """
+    A class to represent a Time-based One-Time Password (TOTP) generator.
+    """
+
+    URL_SCHEME: ClassVar[str] = "otpauth://totp/"
+
+    def __init__(
+        self,
+        secret: str,
+        name: str | None = None,
+        issuer: str | None = None,
+        algorithm: Literal["SHA1", "SHA256", "SHA512"] = "SHA1",
+        digit: int = 6,
+        period: int = 30,
+    ) -> None:
+        """
+        Initializes a TOTP instance.
+
+        Parameters
+        ----------
+        secret : str
+            The shared secret key used to generate the TOTP.
+
+        name : str, optional
+            The name associated with the TOTP. If not provided, defaults to ``"None"``.
+
+        issuer : str, optional
+            The issuer of the TOTP.
+
+        algorithm : Literal["SHA1", "SHA256", "SHA512"], optional
+            The hashing algorithm used to generate the TOTP.
+            Must be one of ``"SHA1"``, ``"SHA256"``, or ``"SHA512"``.
+            Defaults to ``"SHA1"``.
+
+        digit : int, optional
+            The number of digits in the generated TOTP. Must be greater than 0.
+            Defaults to ``6``.
+
+        period : int, optional
+            The time step in seconds for TOTP generation. Must be greater than 0.
+            Defaults to ``30``.
+        """
+        self.secret = secret.upper()
+        self.name = name if name else "None"
+        self.issuer = issuer
+        self.algorithm = algorithm.upper()
+        self.digit = max(digit, 1)  # digit must be larger than 0
+        self.period = max(period, 1)  # period must be larger than 0
+
+    def to_url(self) -> str:
+        """
+        Generates a URL for the TOTP in the otpauth format.
+
+        The URL format is as follows:
+            ``otpauth://totp/<name>?secret=<secret>&issuer=<issuer>&algorithm=<algorithm>&digit=<digit>&period=<period>``
+
+        Returns
+        -------
+        str
+            A URL representing the TOTP in otpauth format.
+        """
+        params = {
+            "secret": self.secret,
+            "issuer": self.issuer,
+            "algorithm": self.algorithm,
+            "digit": self.digit,
+            "period": self.period,
+        }
+        # Filter out None values from the params dictionary
+        filtered_params = {k: v for k, v in params.items() if v is not None}
+        # filtered_params = {k: v for k, v in self.__dict__.items() if v is not None}
+
+        name = quote(self.name)
+        tail = urlencode(filtered_params, quote_via=quote)
+        return f"{self.URL_SCHEME}{name}?{tail}"

absfuyu/tools/shutdownizer.py

@@ -0,0 +1,287 @@
+"""
+Absfuyu: Shutdownizer
+---------------------
+This shutdowns
+
+Version: 5.0.0
+Date updated: 23/02/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["ShutDownizer", "ShutdownEngine"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+import os
+import subprocess
+import sys
+from abc import ABC, abstractmethod
+from datetime import datetime, time, timedelta
+from pathlib import Path
+from typing import Annotated
+
+try:
+    from typing import override  # type: ignore
+except ImportError:
+    from absfuyu.core.decorator import dummy_decorator as override
+
+from absfuyu.core import BaseClass, versionadded, versionchanged
+from absfuyu.logger import logger
+
+# TODO: Schedule shutdown, random time shutdown, test
+
+
+# Class
+# ---------------------------------------------------------------------------
+@versionadded("4.2.0")
+class ShutDownizer(BaseClass):
+    """
+    ShutDownizer
+
+    Shutdown tool because why not
+    """
+
+    __slots__ = ("os", "engine")
+
+    def __init__(self) -> None:
+        self.os: str = sys.platform
+        logger.debug(f"Current OS: {self.os}")
+
+        if self.os in ["win32", "cygwin"]:  # Windows
+            self.engine = ShutdownEngineWin()  # type: ignore
+        elif self.os == "darwin":  # MacOS
+            self.engine = ShutdownEngineMac()  # type: ignore
+        elif self.os == "linux":  # Linux
+            self.engine = ShutdownEngineLinux()  # type: ignore
+        else:
+            raise SystemError("OS not supported")
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}({self.os})"
+
+    def shutdown(self, *args, **kwargs) -> None:
+        """Shutdown"""
+        self.engine.shutdown(*args, **kwargs)
+
+    def restart(self, *args, **kwargs) -> None:
+        """Restart"""
+        self.engine.restart(*args, **kwargs)
+
+    def cancel(self) -> None:
+        """Cancel"""
+        self.engine.cancel()
+
+
+class ShutdownEngine(ABC, BaseClass):
+    """
+    Abstract shutdown class for different type of OS
+    """
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+    def _execute_cmd(self, cmd: str | list) -> None:
+        """Execute the cmd"""
+        try:
+            if isinstance(cmd, str):
+                subprocess.run(cmd.split())
+            elif isinstance(cmd, list):
+                subprocess.run(cmd)
+        except (FileNotFoundError, Exception) as e:
+            logger.error(f'"{cmd}" failed to run: {e}')
+            raise ValueError(f'"{cmd}" failed to run')  # noqa
+
+    def _execute_multiple_cmds(self, cmds: list) -> None:
+        if not isinstance(cmds, list):
+            raise ValueError("cmds must be a <list>")
+        for cmd in cmds:
+            try:
+                logger.debug(f"Executing: {cmd}")
+                self._execute_cmd(cmd)
+                break
+            except Exception as e:
+                logger.error(f'"{cmd}" failed to run: {e}')
+
+    @abstractmethod
+    def shutdown(self, *args, **kwargs) -> None:
+        """Shutdown"""
+        pass
+
+    @abstractmethod
+    def restart(self, *args, **kwargs) -> None:
+        """Restart"""
+        pass
+
+    @abstractmethod
+    def sleep(self, *args, **kwargs) -> None:
+        """Sleep"""
+        pass
+
+    @abstractmethod
+    def abort(self) -> None:
+        """Abort/Cancel"""
+        pass
+
+    def cancel(self) -> None:
+        """Abort/Cancel"""
+        self.abort()
+
+    def _calculate_time(
+        self,
+        h: Annotated[int, "positive"] = 0,
+        m: Annotated[int, "positive"] = 0,
+        aggregate: bool = True,
+    ) -> int:
+        """
+        Calculate time for scheduled shutdown.
+
+        Parameters
+        ----------
+        h : int, optional
+            Hours to add (24h format), by default ``0``
+
+        m : int, optional
+            Minutes to add (24h format), by default ``0``
+
+        aggregate : bool, optional
+            This add hours and and minutes to `time.now()`, by default ``True``
+            - ``True`` : Add hours and minutes to current time
+            - ``False``: Use ``h`` and ``m`` as fixed time point to shutdown
+
+        Returns
+        -------
+        int
+            Seconds left until shutdown.
+        """
+        h = max(0, h)  # Force >= 0
+        m = max(0, m)
+        now = datetime.now()
+        if aggregate:
+            delta = timedelta(hours=h, minutes=m)
+            out = delta.seconds
+        else:
+            new_time = datetime.combine(now.date(), time(hour=h, minute=m))
+            diff = new_time - now
+            out = diff.seconds
+        return out
+
+
+class ShutdownEngineWin(ShutdownEngine):
+    """ShutDownizer - Windows"""
+
+    @override
+    @versionchanged("5.0.0", "Scheduled shutdown")
+    def shutdown(
+        self,
+        h: Annotated[int, "positive"] = 0,
+        m: Annotated[int, "positive"] = 0,
+        aggregate: bool = True,
+    ) -> None:
+        time_until_sd = self._calculate_time(h=h, m=m, aggregate=aggregate)
+        cmds = [f"shutdown -f -s -t {time_until_sd}"]
+        self._execute_multiple_cmds(cmds)
+
+    @override
+    def restart(self, *args, **kwargs) -> None:
+        cmds = ["shutdown -r"]
+        self._execute_multiple_cmds(cmds)
+
+    @override
+    def sleep(self, *args, **kwargs) -> None:
+        cmds = ["rundll32.exe powrprof.dll,SetSuspendState 0,1,0"]
+        self._execute_multiple_cmds(cmds)
+
+    @override
+    def abort(self) -> None:
+        cmds = ["shutdown -a"]
+        self._execute_multiple_cmds(cmds)
+
+    def _punish(self, *, are_you_sure_about_this: bool = False) -> None:
+        """Create a `batch` script that shut down computer when boot up"""
+        if not are_you_sure_about_this:
+            return None
+        try:
+            startup_folder_win = Path(os.getenv("appdata")).joinpath(  # type: ignore
+                "Microsoft", "Windows", "Start Menu", "Programs", "Startup"
+            )
+            with open(startup_folder_win.joinpath("system.bat"), "w") as f:
+                f.write("shutdown -f -s -t 0")
+        except Exception:
+            logger.error("Cannot write file to startup folder")
+
+
+class ShutdownEngineMac(ShutdownEngine):
+    """ShutDownizer - MacOS"""
+
+    @override
+    def shutdown(self, *args, **kwargs) -> None:
+        cmds = [
+            ["osascript", "-e", 'tell application "System Events" to shut down'],
+            "pmset sleepnow",
+            "shutdown -h now",
+            "sudo shutdown -h now",
+        ]
+        self._execute_multiple_cmds(cmds)
+
+    @override
+    def restart(self, *args, **kwargs) -> None:
+        cmds = [
+            ["osascript", "-e", 'tell application "System Events" to restart'],
+            "shutdown -r now",
+            "sudo shutdown -r now",
+        ]
+        self._execute_multiple_cmds(cmds)
+
+    @override
+    def sleep(self, *args, **kwargs) -> None:
+        cmds = [
+            ["osascript", "-e", 'tell application "System Events" to sleep'],
+            "pmset sleepnow",
+            "shutdown -s now",
+            "sudo shutdown -s now",
+        ]
+        self._execute_multiple_cmds(cmds)
+
+    @override
+    def abort(self) -> None:
+        cmds = [
+            ["osascript", "-e", 'tell application "System Events" to cancel shutdown'],
+            "killall shutdown",
+            "shutdown -c",
+            "sudo shutdown -c",
+        ]
+        self._execute_multiple_cmds(cmds)
+
+
+class ShutdownEngineLinux(ShutdownEngine):
+    """ShutDownizer - Linux"""
+
+    @override
+    def shutdown(self, *args, **kwargs) -> None:
+        cmds = [
+            "gnome-session-quit --power-off",
+            "systemctl --user poweroff",
+            "sudo shutdown -h now",
+        ]
+        self._execute_multiple_cmds(cmds)
+
+    @override
+    def restart(self, *args, **kwargs) -> None:
+        cmds = [
+            "gnome-session-quit --reboot",
+            "systemctl reboot",
+            "sudo shutdown -r now",
+        ]
+        self._execute_multiple_cmds(cmds)
+
+    @override
+    def sleep(self, *args, **kwargs) -> None:
+        cmds = ["systemctl suspend", "sudo shutdown -s now"]
+        self._execute_multiple_cmds(cmds)
+
+    @override
+    def abort(self) -> None:
+        cmds = ["sudo shutdown -c"]
+        self._execute_multiple_cmds(cmds)

absfuyu/tools/web.py

@@ -8,7 +8,7 @@ Date updated: 05/04/2024 (dd/mm/yyyy)
 """
 
 # Library
-###########################################################################
+# ---------------------------------------------------------------------------
 import requests
 from bs4 import BeautifulSoup
 
@@ -16,7 +16,7 @@ from absfuyu.logger import logger
 
 
 # Function
-###########################################################################
+# ---------------------------------------------------------------------------
 def soup_link(link: str) -> BeautifulSoup:
     """
     ``BeautifulSoup`` the link
@@ -53,10 +53,3 @@ def gen_random_commit_msg() -> str:
     out = soup_link("https://whatthecommit.com/").get_text()[34:-20]
     logger.debug(out)
     return out  # type: ignore
-
-
-# Run
-###########################################################################
-if __name__ == "__main__":
-    logger.setLevel(10)
-    gen_random_commit_msg()