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

absfuyu/config/config.json

@@ -23,7 +23,7 @@
     },
     "version": {
         "major": 3,
-        "minor": 0,
+        "minor": 1,
         "patch": 0,
         "release_level": "final",
         "serial": 0

absfuyu/extensions/dev/__init__.py

@@ -18,9 +18,11 @@ __all__ = [
 
 # 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
@@ -99,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/"))