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

absfuyu/__init__.py

@@ -12,7 +12,8 @@ USAGE
 -----
 
 Normal import: 
-``import absfuyu``
+>>> import absfuyu
+>>> help(absfuyu)
 
 Using in cmd (`absfuyu[cli]` required): 
 ``$ fuyu --help``
@@ -25,17 +26,19 @@ __title__ = "absfuyu"
 __author__ = "AbsoluteWinter"
 __license__ = "MIT License"
 __all__ = [
-    # default
-    "util",
-    # extra
-    "sort", "fun",
-    # "pkg_data",
-    "game", "tools", "extensions",
-    # config
+    "core",
     "config",
-    # Other
+    "everything",
+    "extensions",
+    "logger",
+    "fun",
+    "game",
+    "general",
+    "pkg_data",
+    "sort",
+    "tools",
+    "util",
     "version",
-    # "everything",
 ]
 
 

absfuyu/__main__.py

@@ -1,12 +1,10 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 """
 ABSFUYU
 ---
 COMMAND LINE INTERFACE
 
-Version: 2.0.0
-Date updated: 22/11/2023 (dd/mm/yyyy)
+Version: 2.0.1
+Date updated: 25/11/2023 (dd/mm/yyyy)
 """
 
 
@@ -22,6 +20,7 @@ try:
 except ImportError:
     # Auto install absfuyu[cli]
     from absfuyu.config import ABSFUYU_CONFIG
+
     if ABSFUYU_CONFIG._get_setting("auto-install-extra").value:
         __cmd: str = "python -m pip install -U absfuyu[cli]".split()
         subprocess.run(__cmd)
@@ -42,7 +41,7 @@ if CLI_MODE:
         colorama.init(autoreset=True)
         __COLOR = __core.Color
     else:
-        __COLOR = {"green":"", "blue":"", "red":"", "yellow":"", "reset":""}
+        __COLOR = {"green": "", "blue": "", "red": "", "yellow": "", "reset": ""}
 
 
 # Main group
@@ -51,17 +50,21 @@ if CLI_MODE:
 def welcome():
     """Welcome message"""
     import os as __os
+
     try:
         user = __os.getlogin()
     except:
         import getpass
+
         user = getpass.getuser()
     welcome_msg = f"{__COLOR['green']}Welcome {__COLOR['red']}{user} {__COLOR['green']}to {__COLOR['blue']}absfuyu's cli"
-    click.echo(f"""
+    click.echo(
+        f"""
         {__COLOR['reset']}{'='*(len(welcome_msg)-20)}
         {welcome_msg}
         {__COLOR['reset']}{'='*(len(welcome_msg)-20)}
-    """)
+    """
+    )
     ABSFUYU_CONFIG.welcome()
 
 
@@ -74,9 +77,11 @@ def greet(name):
 
 @click.command()
 @click.option(
-    "--setting", "-s",
+    "--setting",
+    "-s",
     type=click.Choice(["luckgod", "install-extra"]),
-    help="Toggle on/off selected setting")
+    help="Toggle on/off selected setting",
+)
 def toggle(setting: str):
     """Toggle on/off setting"""
 
@@ -84,7 +89,7 @@ def toggle(setting: str):
     trans = {
         "luckgod": "luckgod-mode",
         "install-extra": "auto-install-extra",
-    } # trans[setting]
+    }  # trans[setting]
 
     if setting is None:
         click.echo(f"{__COLOR['red']}Invalid setting")
@@ -101,18 +106,21 @@ def version():
     click.echo(f"{__COLOR['green']}absfuyu: {__v.__version__}")
 
 
-
 # Do group
 ###########################################################################
 @click.command()
 @click.option(
-    "--force_update/--no-force-update", "-F/-f", "force_update",
-    type=bool, default=True,
+    "--force_update/--no-force-update",
+    "-F/-f",
+    "force_update",
+    type=bool,
+    default=True,
     show_default=True,
-    help="Update the package")
+    help="Update the package",
+)
 def update(force_update: bool):
     """Update the package to latest version"""
-    click.echo(__COLOR['green'])
+    click.echo(__COLOR["green"])
     __v._AbsfuyuPackage.check_for_update(force_update=force_update)
 
 
@@ -125,26 +133,32 @@ def reset():
 
 @click.command()
 @click.option(
-    "--game-name", "-g",
-    type=click.Choice(
-        ["random", "esc", "rps", "ttt"],
-        case_sensitive=False
-    ),
-    default="random", show_default=True,
-    help="Play game")
+    "--game-name",
+    "-g",
+    type=click.Choice(["random", "esc", "rps", "ttt"], case_sensitive=False),
+    default="random",
+    show_default=True,
+    help="Play game",
+)
 @click.option(
-    "--size", "-s",
-    type=int, default=3,
+    "--size",
+    "-s",
+    type=int,
+    default=3,
     show_default=True,
-    help="Change game's size (if any)")
+    help="Change game's size (if any)",
+)
 @click.option(
-    "--mode", "-m",
-    type=str, default=None,
-    help="Change game's gamemode (if any)")
+    "--mode", "-m", type=str, default=None, help="Change game's gamemode (if any)"
+)
 @click.option(
-    "--board-style", "-b", "board_style",
-    type=str, default="1",
-    help="Change game's board style (if any)")
+    "--board-style",
+    "-b",
+    "board_style",
+    type=str,
+    default="1",
+    help="Change game's board style (if any)",
+)
 def game(game_name: str, size: int, mode: str, board_style):
     """
     Play game
@@ -155,8 +169,9 @@ def game(game_name: str, size: int, mode: str, board_style):
     - ttt: Tic Tac Toe
     """
     from absfuyu.game import game_escapeLoop, game_RockPaperScissors
+
     if game_name.startswith("random"):
-        if __randc([0,1]) == 0:
+        if __randc([0, 1]) == 0:
             game_escapeLoop()
         else:
             game_RockPaperScissors()
@@ -167,6 +182,7 @@ def game(game_name: str, size: int, mode: str, board_style):
             game_RockPaperScissors(hard_mode=mode)
         elif game_name.startswith("ttt"):
             from absfuyu.game.tictactoe import game_tictactoe
+
             if board_style == "None":
                 board_style = None
             elif board_style == "1":
@@ -193,15 +209,14 @@ def install(pkg: str):
             click.echo(f"{__COLOR['green']}absfuyu[{pkg}] installed")
     else:
         click.echo(f"{__COLOR['green']}absfuyu[{pkg}] installed")
-    
+
 
 @click.command()
 def advice():
     """Give some recommendation when bored"""
     from .fun import im_bored
-    click.echo(f"{__COLOR['green']}{im_bored()}")
-
 
+    click.echo(f"{__COLOR['green']}{im_bored()}")
 
 
 @click.group(name="do")
@@ -209,6 +224,7 @@ def do_group():
     """Perform functionalities"""
     pass
 
+
 do_group.add_command(reset)
 do_group.add_command(update)
 do_group.add_command(game)
@@ -216,19 +232,20 @@ do_group.add_command(install)
 do_group.add_command(advice)
 
 
-
 # Main group init
 ###########################################################################
 @click.group()
 def main():
     """
     absfuyu's command line interface
-    
+
     Usage:
         python -m absfuyu --help
         fuyu --help
     """
     pass
+
+
 main.add_command(welcome)
 main.add_command(greet)
 main.add_command(toggle)
@@ -240,4 +257,4 @@ main.add_command(do_group)
 ###########################################################################
 if __name__ == "__main__":
     if CLI_MODE:
-        main()
+        main()

absfuyu/config/config.json

@@ -22,9 +22,9 @@
         }
     },
     "version": {
-        "major": 2,
-        "minor": 8,
-        "patch": 1,
+        "major": 3,
+        "minor": 1,
+        "patch": 0,
         "release_level": "final",
         "serial": 0
     }

absfuyu/core.py

@@ -3,8 +3,8 @@ Absfuyu: Core
 -------------
 Contain type hints and other stuffs
 
-Version: 2.1.5
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 2.1.9
+Date updated: 27/11/2023 (dd/mm/yyyy)
 """
 
 
@@ -12,27 +12,24 @@ Date updated: 24/11/2023 (dd/mm/yyyy)
 ###########################################################################
 __all__ = [
     # module
-    "ModulePackage", "ModuleList",
+    "ModulePackage",
+    "ModuleList",
     # color
     "Color",
     "CLITextColor",
     # path
-    "CORE_PATH", "CONFIG_PATH", "DATA_PATH"
+    "CORE_PATH",
+    "CONFIG_PATH",
+    "DATA_PATH",
 ]
 
-ModulePackage = [
-    "all",
-    "cli",
-    "beautiful", "extra",
-    "full",
-    "dev"
-]
+ModulePackage = ["all", "cli", "beautiful", "extra", "res", "full", "dev"]
 ModuleList = [
-    "collections",
     "config",
     "extensions",
     "fun",
     "game",
+    "general",
     "pkg_data",
     "sort",
     "tools",
@@ -44,6 +41,16 @@ ModuleList = [
 # Library
 ###########################################################################
 from pathlib import Path
+# import sys
+
+# if sys.version_info.minor >= 10:
+#     from importlib.resources import files
+# else:
+#     try:
+#         from importlib_resources import files
+#     except:
+#         raise ImportError("Please install importlib-resources")
+
 
 try:
     import colorama as __colorama
@@ -64,40 +71,47 @@ if __colorama is not None:
         "RED": __colorama.Fore.RED,
         "yellow": __colorama.Fore.LIGHTYELLOW_EX,
         "YELLOW": __colorama.Fore.YELLOW,
-        "reset": __colorama.Fore.RESET
+        "reset": __colorama.Fore.RESET,
     }
 else:
     Color = {
         "green": "",
         "GREEN": "",
         "blue": "",
-        "BLUE":"",
+        "BLUE": "",
         "red": "",
         "RED": "",
         "yellow": "",
         "YELLOW": "",
-        "reset": ""
+        "reset": "",
     }
 
 
 class CLITextColor:
     """Color code for text in terminal"""
-    WHITE     = "\x1b[37m"
-    BLACK     = "\x1b[30m"
-    BLUE      = "\x1b[34m"
-    GRAY      = "\x1b[90m"
-    GREEN     = "\x1b[32m"
-    RED       = "\x1b[91m"
-    DARK_RED  = "\x1b[31m"
-    MAGENTA   = "\x1b[35m"
-    YELLOW    = "\x1b[33m"
-    RESET     = "\x1b[39m"
+
+    WHITE = "\x1b[37m"
+    BLACK = "\x1b[30m"
+    BLUE = "\x1b[34m"
+    GRAY = "\x1b[90m"
+    GREEN = "\x1b[32m"
+    RED = "\x1b[91m"
+    DARK_RED = "\x1b[31m"
+    MAGENTA = "\x1b[35m"
+    YELLOW = "\x1b[33m"
+    RESET = "\x1b[39m"
 
 
 # Path
 ###########################################################################
 # CORE_PATH = Path(os.path.abspath(os.path.dirname(__file__)))
 CORE_PATH = Path(__file__).parent.absolute()
+# CORE_PATH = files("absfuyu")
 CONFIG_PATH = CORE_PATH.joinpath("config", "config.json")
 DATA_PATH = CORE_PATH.joinpath("pkg_data")
 
+
+# Run
+###########################################################################
+if __name__ == "__main__":
+    print(CORE_PATH)

absfuyu/everything.py

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
 Absfuyu: Everything
 -------------------
 Everything has to offer in this package
 
-Version: 2.0.0
-Date updated: 24/11/2023 (mm/dd/yyyy)
+Version: 2.0.1
+Date updated: 26/11/2023 (mm/dd/yyyy)
 
 Usage:
 ------
@@ -23,7 +22,7 @@ from absfuyu.logger import *
 from absfuyu.sort import *
 from absfuyu.version import *
 
-from absfuyu.collections import *
+from absfuyu.general import *
 from absfuyu.extensions import *
 from absfuyu.game import *
 from absfuyu.tools import *
@@ -32,4 +31,4 @@ from absfuyu.util import *
 
 # Is loaded
 ###########################################################################
-__IS_EVERYTHING = True
+__IS_EVERYTHING = True

absfuyu/extensions/__init__.py

@@ -6,5 +6,6 @@ Version: 1.0.1
 Date updated: 24/11/2023 (dd/mm/yyyy)
 """
 
-def isloaded():
-    return True
+
+def is_loaded():
+    return True

absfuyu/extensions/dev/__init__.py

@@ -11,16 +11,18 @@ Date updated: 23/11/2023 (dd/mm/yyyy)
 # Module level
 ###########################################################################
 __all__ = [
-    "password_check", "fib",
+    "password_check",
+    "fib",
 ]
 
 
 # Library
 ###########################################################################
-import re
-import os as __os
+import base64
+from collections import deque
 from functools import lru_cache
-
+import re
+from typing import Dict, TypedDict, Final, List, NamedTuple
 
 
 # PASSWORD CHECKER
@@ -49,24 +51,27 @@ def password_check(password: str) -> bool:
     lowercase_error = re.search(r"[a-z]", password) is None
 
     # searching for symbols
-    symbols = re.compile(r"[ !#$%&'()*+,-./[\\\]^_`{|}~"+r'"]')
+    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,
+        "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']
-
+    return detail["password_ok"]
 
 
 # FIBONACCI WITH CACHE
@@ -76,13 +81,13 @@ def fib(n: int) -> int:
     # max recursion is 484
     if n < 2:
         return n
-    return fib(n-1) + fib(n-2)
-
+    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)
@@ -96,3 +101,141 @@ def optional_import(module: str, name: str = None, package: str = None):
             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
+        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/"))