rc-toolkit 0.1.0__tar.gz

rc-toolkit-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.1
+Name: rc-toolkit
+Version: 0.1.0
+License: MIT
+Author-email: break-soul <57186766+break-soul@users.noreply.github.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# rc-toolkit

rc-toolkit-0.1.0/README.md

@@ -0,0 +1 @@
+# rc-toolkit

rc-toolkit-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "rc-toolkit"
+version = "0.1.0"
+description = ""
+authors = [
+    { name = "break-soul", email = "57186766+break-soul@users.noreply.github.com" },
+]
+dependencies = [
+    "rclog>=1.4.0",
+]
+requires-python = ">=3.8"
+readme = "README.md"
+
+[project.license]
+text = "MIT"
+
+[build-system]
+requires = [
+    "pdm-pep517>=1.0.0",
+]
+build-backend = "pdm.pep517.api"

rc-toolkit-0.1.0/src/base/control.py

@@ -0,0 +1,86 @@
+"""
+This module contains functions to control the Python interpreter.
+"""
+
+import os
+import sys
+import importlib.util
+
+from typing import NoReturn, TYPE_CHECKING
+
+from rclog import get_log
+
+from .control import lazy_load
+
+if TYPE_CHECKING:
+    from logging import Logger
+
+
+class Env:
+    @staticmethod
+    def set_env(key: str, value: str) -> None:
+        os.environ[key] = value
+
+    @staticmethod
+    def get_env(key: str, default: Optional[str] = None) -> str:
+        return os.environ.get(key, default)
+
+    @staticmethod
+    @lazy_load
+    def is_debug() -> bool:
+        """
+        Check whether it == DEBUG mode
+
+        Returns:
+            bool: __debug__
+        """
+        return bool(Env.get_env("DEBUG", default=0))
+
+@lazy_load
+def log() -> "Logger":
+    return get_log("RCTK.base.pycontrol")
+
+
+def get_pycache() -> str:
+    return sys.pycache_prefix()
+
+
+def add_path(path: str) -> NoReturn:
+    sys.path.append(path)
+
+
+def remove_path(path: str) -> NoReturn:
+    sys.path.remove(path)
+
+
+class Compile:
+
+    @staticmethod
+    def compile_file(
+        file, cfile=None, dfile=None, doraise=False, optimize=1, quiet=0
+    ) -> None:
+        log.info("Compile {file}".format(file=file))
+        import py_compile
+
+    @staticmethod
+    def compile_dir(
+        path, cfile=None, dfile=None, doraise=False, optimize=1, quiet=0
+    ) -> None:
+        Compile.compile_file(file)
+
+
+def set_global(key: str, value: object) -> NoReturn:
+    import builtins
+
+    log().warning("Hooking builtin {} as {}".format(key, str(value)))
+    builtins.__dict__[key] = value
+
+
+def is_module(name, path: str) -> bool: ...
+
+
+def get_module(path: str) -> object: ...
+
+
+def exit_py() -> NoReturn:
+    sys.exit()

rc-toolkit-0.1.0/src/base/enums.py

@@ -0,0 +1,172 @@
+"""
+Store the enums used in the package.
+"""
+
+from enum import Enum
+from typing import overload, Tuple
+
+from ..system.base import System, Arch
+
+
+def mode_func(*args, **kw): ...
+
+
+class _MISSING_TYPE:
+    pass
+
+
+class Release(Enum):
+    ALPHA = "a"
+    BETA = "b"
+    RELEASE = "r"
+    DEBUG = "d"
+
+    @classmethod
+    def from_str(cls, rel_str: str) -> "Release":
+        if rel_str == "a":
+            return cls.ALPHA
+        if rel_str == "b":
+            return cls.BETA
+        if rel_str == "r":
+            return cls.RELEASE
+        if rel_str == "d":
+            return cls.DEBUG
+        raise ValueError("Invalid release string")
+
+
+MISSING = _MISSING_TYPE()
+
+
+class Version:
+    def __init__(self, ver_1: int, ver_2: int, ver_3: int, build: int = 0):
+        self.ver: Tuple[int, int, int] = (ver_1, ver_2, ver_3)
+        self.build: int = build
+
+    @classmethod
+    def from_str(cls, ver_str: str) -> "Version":
+        return cls(*cls.dump_ver(ver_str))
+
+    def set_build(self, build: int) -> None:
+        self.build = build
+
+    def get_build(self) -> int:
+        return self.build
+
+    def set_ver(self, ver: Tuple[int, int, int]) -> None:
+        self.ver = ver
+
+    def get_ver(self) -> Tuple[int, int, int]:
+        return self.ver
+
+    def update(self, ver_path: int = 3) -> None:
+        if ver_path < 1 or ver_path > 3:
+            raise ValueError("ver_path must be between 1 and 3")
+        ver_list = list(self.ver)
+        ver_list[ver_path - 1] += 1
+        self.ver = tuple(ver_list)
+
+        if self.build != 0:
+            self.build += 1
+
+    @overload
+    def dump_ver(ver_str: str) -> Tuple[int, int, int]: ...
+    @overload
+    def dump_ver(ver_str: str) -> Tuple[int, int, int, int]: ...
+    @staticmethod
+    def dump_ver(ver_str: str):
+        def _str_ver(ver_str: str) -> Tuple[int, int, int]:
+            return tuple(map(int, ver_str.split(".")))
+
+        ver_list = ver_str.split("_")
+        ver = _str_ver(ver_list[0])
+        if len(ver_list) > 1:
+            if ver_list[1].startswith("b"):
+                build = int(ver_list[1][1:])
+                return ver + (build,)
+        return ver
+
+    def __str__(self) -> str:
+        rt = f"v{self.ver[0]}.{self.ver[1]}.{self.ver[2]}"
+        if self.build == 0:
+            return rt
+        return rt + f"_b{self.build}"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    # region
+    def __eq__(self, other: "Version") -> bool:
+        return self.ver == other.ver and self.build == other.build
+
+    def __ne__(self, other: "Version") -> bool:
+        return not self.__eq__(other)
+
+    def __lt__(self, other: "Version") -> bool:
+        return self.ver < other.ver or (
+            self.ver == other.ver and self.build < other.build
+        )
+
+    def __le__(self, other: "Version") -> bool:
+        return self.ver < other.ver or (
+            self.ver == other.ver and self.build <= other.build
+        )
+
+    def __gt__(self, other: "Version") -> bool:
+        return self.ver > other.ver or (
+            self.ver == other.ver and self.build > other.build
+        )
+
+    def __ge__(self, other: "Version") -> bool:
+        return self.ver > other.ver or (
+            self.ver == other.ver and self.build >= other.build
+        )
+
+    # endregion
+
+
+class Meta:
+    def __init__(
+        self,
+        name: str,
+        ver: Version = Version(0, 0, 0),
+        release: Release = Release.RELEASE,
+        platform: System = System.get_os(),
+        arch: Arch = Arch.get_arch(),
+    ):
+        self.name: str = name
+        self.ver: Version = ver
+        self.release: Release = release
+        self.platform: System = platform
+        self.arch: Arch = arch
+
+    def __str__(self) -> str:
+        rt = f"{self.name}"
+        if self.ver != Version(0, 0, 0):
+            rt += f"-{str(self.ver)}"
+        if self.release and self.release != MISSING:
+            rt += f"-r{self.release.value}"
+        if self.platform != System.Other and self.platform != MISSING:
+            rt += f"-p{self.platform.value}"
+        if self.arch != Arch.Other and self.arch != MISSING:
+            rt += f"-a_{self.arch.value}"
+        return rt
+
+    def __repr__(self):
+        return self.__str__()
+
+    @classmethod
+    def dump(cls, mate_str) -> str:
+        split = mate_str.split("-")
+        lt = list([split[0], MISSING, MISSING, MISSING, MISSING])
+        for_map = {
+            "v": [1, Version.from_str],
+            "r": [2, Release.from_str],
+            "p": [3, System.get_os],
+            "a": [4, Arch.get_arch],
+        }
+
+        for s in split[1:]:
+            if s[0] in for_map:
+                lt[for_map[s[0]][0]] = for_map[s[0]][1](s[1:])
+
+        return cls(*lt)

rc-toolkit-0.1.0/src/base/tools.py

@@ -0,0 +1,23 @@
+
+
+def lazy_load(func, *args, **kwargs):
+
+    class LazyLoad:
+        def __init__(self, func, *args, **kwargs):
+            self.func = func
+            self.result = None
+            self.has_run = False
+            self.args = args
+            self.kwargs = kwargs
+
+        def __call__(self):
+            if not self.has_run:
+                self.result = self.func(*self.args, **self.kwargs)
+                self.has_run = True
+            return self.result
+
+        def __getattr__(self, name):
+            obj = self.__call__()
+            return getattr(obj, name)
+
+    return LazyLoad(func, *args, **kwargs)

rc-toolkit-0.1.0/src/io/file.py

@@ -0,0 +1,32 @@
+"""
+File IO module
+"""
+
+from os import path, makedirs
+from pathlib import Path
+from typing import NoReturn
+
+
+def get_dir() -> tuple: ...
+
+
+def mkdir(file_path: str) -> NoReturn:
+    """
+    make log file dirs
+
+    Args:
+        file_path (str): file path
+    """
+
+    dir_path = Path(file_path).parent
+    if not path.isdir(dir_path):
+        try:
+            makedirs(dir_path)
+        except Exception:  # pylint: disable=broad-exception-caught
+            raise
+
+
+def try_open(): ...
+
+
+def try_read(): ...

rc-toolkit-0.1.0/src/io/printer.py

@@ -0,0 +1,2 @@
+
+

rc-toolkit-0.1.0/src/system/base.py

@@ -0,0 +1,54 @@
+import platform
+from enum import Enum
+from functools import lru_cache
+
+
+class System(Enum):
+    Other = "other"
+    AIX = "aix"
+    Linux = "linux"
+    Win32 = "win32"
+    Cygwin = "cygwin"
+    macOS = "darwin"
+    FreeBSD = "freebsd"
+
+    @classmethod
+    @lru_cache(1)
+    def get_os(cls, os_str: str = platform.system()) -> "System":
+        if os_str == "win32":
+            return cls.Win32
+        if os_str == "linux":
+            return cls.Linux
+        if os_str == "darwin":
+            return cls.macOS
+        if os_str == "aix":
+            return cls.AIX
+        if os_str == "cygwin":
+            return cls.Cygwin
+        if os_str.startswith("freebsd"):
+            return cls.FreeBSD
+        return cls.Other
+
+
+class Arch(Enum):
+    x86 = "i386"
+    x64 = "amd64"
+    ARM = "arm"
+    ARM64 = "arm64"
+    Other = "other"
+
+    @classmethod
+    @lru_cache(1)
+    def get_arch(cls, arch_str: str = platform.machine()) -> "Arch":
+        arch_str = arch_str.lower().replace("_", "")
+        if arch_str == "amd64":
+            return cls.x64
+        if arch_str == "i386":
+            return cls.x86
+        if arch_str == "arm":
+            return cls.ARM
+        if arch_str == "arm64":
+            return cls.ARM64
+        return cls.Other
+
+env_os = System.get_os()