easyrip 3.13.2__py3-none-any.whl → 4.9.1__py3-none-any.whl

easyrip/easyrip_config/config.py

@@ -0,0 +1,269 @@
+import json
+import os
+from pathlib import Path
+from typing import Literal, get_origin, overload
+
+from ..easyrip_log import log
+from ..easyrip_mlang import all_supported_lang_map, gettext
+from ..global_val import CONFIG_DIR
+from ..utils import type_match
+from .config_key import CONFIG_TYPE_DICT, CONFIG_VERSION, Config_key
+
+CONFIG_DEFAULT_DICT: dict[Config_key, str | bool | list[str]] = {
+    Config_key.language: "auto",
+    Config_key.check_update: True,
+    Config_key.check_dependent: True,
+    Config_key.startup_dir: "",
+    Config_key.startup_dir_blacklist: [],
+    Config_key.force_log_file_path: "",
+    Config_key.log_print_level: log.LogLevel.send.name,
+    Config_key.log_write_level: log.LogLevel.send.name,
+    Config_key.save_prompt_history: True,
+}
+
+assert all(k in CONFIG_DEFAULT_DICT for k in Config_key), [
+    k.name for k in Config_key if k not in CONFIG_DEFAULT_DICT
+]
+
+
+class config:
+    _config_dir: Path
+    _config_file: Path
+    _config: dict | None = None
+
+    @classmethod
+    def init(cls) -> None:
+        cls._config_dir = CONFIG_DIR
+        cls._config_file = cls._config_dir / "config.json"
+
+        if not cls._config_file.is_file():
+            cls._config_dir.mkdir(exist_ok=True)
+            with cls._config_file.open("wt", encoding="utf-8", newline="\n") as f:
+                config_default_dict: dict[str, str | bool | list[str]] = {
+                    k.name: v for k, v in CONFIG_DEFAULT_DICT.items()
+                }
+                json.dump(
+                    {
+                        "version": CONFIG_VERSION,
+                        "user_profile": config_default_dict,
+                    },
+                    f,
+                    ensure_ascii=False,
+                    indent=3,
+                )
+        else:
+            with cls._config_file.open("rt", encoding="utf-8") as f:
+                try:
+                    data = json.load(f)
+                    if data.get("version") != CONFIG_VERSION:
+                        log.warning(
+                            "The config version is not match, use '{}' to regenerate config file",
+                            "config clear",
+                        )
+                except json.JSONDecodeError as e:
+                    log.error(f"{e!r} {e}", deep=True)
+
+        cls._read_config()
+
+    @classmethod
+    def open_config_dir(cls) -> None:
+        if not cls._config_dir.is_dir():
+            cls.init()
+        os.startfile(cls._config_dir)
+
+    @classmethod
+    def regenerate_config(cls) -> None:
+        cls._config_file.unlink(missing_ok=True)
+
+        cls.init()
+        log.info("Regenerate config file")
+
+    @classmethod
+    def _read_config(cls) -> bool:
+        try:
+            if not cls._config_dir.is_dir():
+                raise AttributeError
+        except AttributeError:
+            cls.init()
+
+        with cls._config_file.open("rt", encoding="utf-8") as f:
+            try:
+                cls._config = json.load(f)
+            except json.JSONDecodeError as e:
+                log.error(f"{e!r} {e}", deep=True)
+                return False
+            return True
+
+    @classmethod
+    def _write_config(cls, new_config: dict | None = None) -> bool:
+        if not cls._config_dir.is_dir():
+            cls.init()
+        if new_config is not None:
+            cls._config = new_config
+        del new_config
+
+        with cls._config_file.open("wt", encoding="utf-8", newline="\n") as f:
+            try:
+                json.dump(cls._config, f, ensure_ascii=False, indent=3)
+            except json.JSONDecodeError as e:
+                log.error(f"{e!r} {e}", deep=True)
+                return False
+            return True
+
+    @classmethod
+    def set_user_profile(
+        cls,
+        key: str,
+        val: str | bool | list[str],
+    ) -> bool:
+        if cls._config is None and not cls._read_config():
+            return False
+
+        if cls._config is None:
+            log.error("Config is None")
+            return False
+
+        if "user_profile" not in cls._config:
+            log.error("User profile is not found in config file")
+            return False
+
+        if key in Config_key._member_map_:
+            need_type = CONFIG_TYPE_DICT[Config_key[key]]
+            if not type_match(val, need_type):
+                log.error(
+                    "Type mismatch: need '{}'",
+                    need_type if get_origin(need_type) else need_type.__name__,
+                )
+                return False
+            cls._config["user_profile"][key] = val
+        else:
+            log.error("Key '{}' is not found in user profile", key)
+            return False
+        return cls._write_config()
+
+    @overload
+    @classmethod
+    def get_user_profile(
+        cls,
+        config_key: Literal[
+            Config_key.language,
+            Config_key.startup_dir,
+            Config_key.force_log_file_path,
+            Config_key.log_print_level,
+            Config_key.log_write_level,
+        ],
+    ) -> str | None: ...
+
+    @overload
+    @classmethod
+    def get_user_profile(
+        cls,
+        config_key: Literal[
+            Config_key.check_update,
+            Config_key.check_dependent,
+            Config_key.save_prompt_history,
+        ],
+    ) -> bool | None: ...
+
+    @overload
+    @classmethod
+    def get_user_profile(
+        cls,
+        config_key: Literal[Config_key.startup_dir_blacklist],
+    ) -> list[str] | None: ...
+
+    @overload
+    @classmethod
+    def get_user_profile(
+        cls,
+        config_key: str,
+    ) -> str | bool | list[str] | None: ...
+
+    @classmethod
+    def get_user_profile(
+        cls,
+        config_key: Config_key | str,
+    ) -> str | bool | list[str] | None:
+        key = config_key.name if isinstance(config_key, Config_key) else config_key
+
+        if key not in Config_key._member_map_:
+            log.error("The key '{}' is not a config", key)
+            return None
+
+        if cls._config is None:
+            cls._read_config()
+        if cls._config is None:
+            return None
+        if not isinstance(cls._config["user_profile"], dict):
+            log.error("User profile is not a valid dictionary")
+            return None
+        if key not in cls._config["user_profile"]:
+            log.error("Key '{}' is not found in user profile", key)
+            return None
+        return cls._config["user_profile"][key]
+
+    @classmethod
+    def show_config_list(cls) -> None:
+        if cls._config is None:
+            cls.init()
+        if cls._config is None:
+            log.error("Config is None")
+            return
+
+        user_profile: dict = cls._config["user_profile"]
+        length_key = max(len(k) for k in user_profile)
+        length_val = max(len(str(v)) for v in user_profile.values())
+        for k, v in user_profile.items():
+            log.send(
+                f"{k:>{length_key}} = {v!s:<{length_val}} - {cls._get_config_about(k)}",
+            )
+
+    @classmethod
+    def _get_config_about(cls, key: str) -> str:
+        return (
+            {
+                Config_key.language.name: gettext(
+                    "Easy Rip's language, support incomplete matching. Default: {}. Supported: {}",
+                    CONFIG_DEFAULT_DICT[Config_key.language],
+                    ", ".join(("auto", *(str(tag) for tag in all_supported_lang_map))),
+                ),
+                Config_key.check_update.name: gettext(
+                    "Auto check the update of Easy Rip. Default: {}",
+                    CONFIG_DEFAULT_DICT[Config_key.check_update],
+                ),
+                Config_key.check_dependent.name: gettext(
+                    "Auto check the versions of all dependent programs. Default: {}",
+                    CONFIG_DEFAULT_DICT[Config_key.check_dependent],
+                ),
+                Config_key.startup_dir.name: gettext(
+                    "Program startup directory, when the value is empty, starts in the working directory. Default: {}",
+                    CONFIG_DEFAULT_DICT[Config_key.startup_dir] or '""',
+                ),
+                Config_key.startup_dir_blacklist.name: gettext(
+                    "Directory list. When the startup directory is a blacklisted directory, rollback to startup directory. Default: {}",
+                    CONFIG_DEFAULT_DICT[Config_key.startup_dir] or '""',
+                ),
+                Config_key.force_log_file_path.name: gettext(
+                    "Force change of log file path, when the value is empty, it is the working directory. Default: {}",
+                    CONFIG_DEFAULT_DICT[Config_key.force_log_file_path] or '""',
+                ),
+                Config_key.log_print_level.name: gettext(
+                    "Logs this level and above will be printed, and if the value is '{}', they will not be printed. Default: {}. Supported: {}",
+                    log.LogLevel.none.name,
+                    CONFIG_DEFAULT_DICT[Config_key.log_print_level],
+                    ", ".join(log.LogLevel._member_names_),
+                ),
+                Config_key.log_write_level.name: gettext(
+                    "Logs this level and above will be written, and if the value is '{}', the '{}' only be written when 'server', they will not be written. Default: {}. Supported: {}",
+                    log.LogLevel.none.name,
+                    log.LogLevel.send.name,
+                    CONFIG_DEFAULT_DICT[Config_key.log_write_level],
+                    ", ".join(log.LogLevel._member_names_),
+                ),
+                Config_key.save_prompt_history.name: gettext(
+                    "Save prompt history to config directory, otherwise save to memory. Take effect after reboot. Default: {}",
+                    CONFIG_DEFAULT_DICT[Config_key.save_prompt_history],
+                ),
+            }
+            | (cls._config or {})
+        ).get(key, "None about")

easyrip/easyrip_config/config_key.py

@@ -0,0 +1,28 @@
+import enum
+
+CONFIG_VERSION = "4.6.0"
+
+
+class Config_key(enum.Enum):
+    language = enum.auto()
+    check_update = enum.auto()
+    check_dependent = enum.auto()
+    startup_dir = enum.auto()
+    startup_dir_blacklist = enum.auto()
+    force_log_file_path = enum.auto()
+    log_print_level = enum.auto()
+    log_write_level = enum.auto()
+    save_prompt_history = enum.auto()
+
+
+CONFIG_TYPE_DICT: dict[Config_key, type] = {
+    Config_key.language: str,
+    Config_key.check_update: bool,
+    Config_key.check_dependent: bool,
+    Config_key.startup_dir: str,
+    Config_key.startup_dir_blacklist: list[str],
+    Config_key.force_log_file_path: str,
+    Config_key.log_print_level: str,
+    Config_key.log_write_level: str,
+    Config_key.save_prompt_history: bool,
+}

easyrip/easyrip_log.py

@@ -5,27 +5,30 @@ import os
 import sys
 import traceback
 from ctypes import wintypes
+from typing import TextIO
+
+from prompt_toolkit import ANSI, print_formatted_text
 
 from . import easyrip_web
 from .easyrip_mlang import gettext
 
-__all__ = ["Event", "log"]
+__all__ = ["log"]
 
 
 class Event:
     @staticmethod
-    def append_http_server_log_queue(message: tuple[str, str, str]):
-        pass
+    def append_http_server_log_queue(message: tuple[str, str, str], /) -> None: ...
 
 
 class log:
     @classmethod
-    def init(cls):
+    def init(cls) -> None:
         """
+        初始化日志功能
+
         1. 获取终端颜色
-        2. 写入 \\</div>
+        2. 写入 \\</div> 以闭合已有日志
         """
-
         # 获取终端颜色
         if os.name == "nt":
 
@@ -90,6 +93,7 @@ class log:
             cls.write_html_log("</div></div></div>")
 
     class LogLevel(enum.Enum):
+        _detail = enum.auto()
         debug = enum.auto()
         send = enum.auto()
         info = enum.auto()
@@ -102,7 +106,7 @@ class log:
         only_print = enum.auto()
         only_write = enum.auto()
 
-    html_filename: str = "encoding_log.html"  # 在调用前覆写
+    html_filename: str = "EasyRip_log.html"  # 在调用前覆写
     print_level: LogLevel = LogLevel.send
     write_level: LogLevel = LogLevel.send
 
@@ -121,7 +125,24 @@ class log:
     error_num: int = 0
     send_num: int = 0
 
-    hr = "———————————————————————————————————"
+    @staticmethod
+    def print(
+        value: str,
+        end: str = "",
+        file: TextIO = sys.stdout,
+    ) -> None:
+        try:
+            print_formatted_text(
+                ANSI(value),
+                end=end,
+                file=file,
+            )
+        except Exception:
+            print(
+                value,
+                end=end,
+                file=file,
+            )
 
     @classmethod
     def _do_log(
@@ -130,12 +151,15 @@ class log:
         mode: LogMode,
         message: object,
         *fmt_args: object,
+        stream: TextIO,
+        print_level: LogLevel,
+        write_level: LogLevel,
         is_format: bool = True,
         is_deep: bool = False,
         is_server: bool = False,
         http_send_header: str = "",
         **fmt_kwargs: object,
-    ):
+    ) -> None:
         if log_level == cls.LogLevel.none:
             return
 
@@ -159,20 +183,24 @@ class log:
                 if (
                     mode != cls.LogMode.only_write
                     and cls.print_level.value <= cls.LogLevel.debug.value
+                    and cls.print_level.value <= print_level.value
                 ):
-                    print(
-                        f"{time_str}\033[{cls.debug_color}m [DEBUG] {message}\033[{cls.default_foreground_color}m"
+                    cls.print(
+                        f"{time_str}\033[{cls.debug_color}m [DEBUG] {message}\033[{cls.default_foreground_color}m\n",
+                        end="",
+                        file=stream,
                     )
 
                 if (
                     mode != cls.LogMode.only_print
                     and cls.write_level.value <= cls.LogLevel.debug.value
+                    and cls.write_level.value <= write_level.value
                 ):
                     cls.write_html_log(
                         f'<div style="background-color:#b4b4b4;margin-bottom:2px;white-space:pre-wrap;"><span style="color:green;">{time_now}</span> <span style="color:green;">[DEBUG] {message}</span></div>'
                     )
 
-                Event.append_http_server_log_queue((time_now, "INFO", message))
+                Event.append_http_server_log_queue((time_now, "DEBUG", message))
 
             case cls.LogLevel.info:
                 cls.info_num += 1
@@ -180,14 +208,18 @@ class log:
                 if (
                     mode != cls.LogMode.only_write
                     and cls.print_level.value <= cls.LogLevel.info.value
+                    and cls.print_level.value <= print_level.value
                 ):
-                    print(
-                        f"{time_str}\033[{cls.info_color}m [INFO] {message}\033[{cls.default_foreground_color}m"
+                    cls.print(
+                        f"{time_str}\033[{cls.info_color}m [INFO] {message}\033[{cls.default_foreground_color}m\n",
+                        end="",
+                        file=stream,
                     )
 
                 if (
                     mode != cls.LogMode.only_print
                     and cls.write_level.value <= cls.LogLevel.info.value
+                    and cls.write_level.value <= write_level.value
                 ):
                     cls.write_html_log(
                         f'<div style="background-color:#b4b4b4;margin-bottom:2px;white-space:pre-wrap;"><span style="color:green;">{time_now}</span> <span style="color:blue;">[INFO] {message}</span></div>'
@@ -201,15 +233,18 @@ class log:
                 if (
                     mode != cls.LogMode.only_write
                     and cls.print_level.value <= cls.LogLevel.warning.value
+                    and cls.print_level.value <= print_level.value
                 ):
-                    print(
-                        f"{time_str}\033[{cls.warning_color}m [WARNING] {message}\033[{cls.default_foreground_color}m",
-                        file=sys.stderr,
+                    cls.print(
+                        f"{time_str}\033[{cls.warning_color}m [WARNING] {message}\033[{cls.default_foreground_color}m\n",
+                        end="",
+                        file=stream,
                     )
 
                 if (
                     mode != cls.LogMode.only_print
                     and cls.write_level.value <= cls.LogLevel.warning.value
+                    and cls.write_level.value <= write_level.value
                 ):
                     cls.write_html_log(
                         f'<div style="background-color:#b4b4b4;margin-bottom:2px;white-space:pre-wrap;"><span style="color:green;">{time_now}</span> <span style="color:yellow;">[WARNING] {message}</span></div>'
@@ -223,15 +258,18 @@ class log:
                 if (
                     mode != cls.LogMode.only_write
                     and cls.print_level.value <= cls.LogLevel.error.value
+                    and cls.print_level.value <= print_level.value
                 ):
-                    print(
-                        f"{time_str}\033[{cls.error_color}m [ERROR] {message}\033[{cls.default_foreground_color}m",
-                        file=sys.stderr,
+                    cls.print(
+                        f"{time_str}\033[{cls.error_color}m [ERROR] {message}\033[{cls.default_foreground_color}m\n",
+                        end="",
+                        file=stream,
                     )
 
                 if (
                     mode != cls.LogMode.only_print
                     and cls.write_level.value <= cls.LogLevel.error.value
+                    and cls.write_level.value <= write_level.value
                 ):
                     cls.write_html_log(
                         f'<div style="background-color:#b4b4b4;margin-bottom:2px;white-space:pre-wrap;"><span style="color:green;">{time_now}</span> <span style="color:red;">[ERROR] {message}</span></div>'
@@ -243,12 +281,22 @@ class log:
                 cls.send_num += 1
 
                 if is_server or easyrip_web.http_server.Event.is_run_command:
-                    if cls.print_level.value <= cls.LogLevel.send.value:
-                        print(
-                            f"{time_str}\033[{cls.send_color}m [Send] {message}\033[{cls.default_foreground_color}m"
+                    if (
+                        mode != cls.LogMode.only_write
+                        and cls.print_level.value <= cls.LogLevel.send.value
+                        and cls.print_level.value <= print_level.value
+                    ):
+                        cls.print(
+                            f"{time_str}\033[{cls.send_color}m [Send] {message}\033[{cls.default_foreground_color}m\n",
+                            end="",
+                            file=stream,
                         )
 
-                    if cls.write_level.value <= cls.LogLevel.send.value:
+                    if (
+                        mode != cls.LogMode.only_print
+                        and cls.write_level.value <= cls.LogLevel.send.value
+                        and cls.write_level.value <= write_level.value
+                    ):
                         cls.write_html_log(
                             f'<div style="background-color:#b4b4b4;margin-bottom:2px;white-space:pre-wrap;"><span style="color:green;white-space:pre-wrap;">{time_now}</span> <span style="color:deeppink;">[Send] <span style="color:green;">{http_send_header}</span>{message}</span></div>'
                         )
@@ -257,8 +305,9 @@ class log:
                         (http_send_header, "Send", message)
                     )
                 elif cls.print_level.value <= cls.LogLevel.send.value:
-                    print(
-                        f"\033[{cls.send_color}m{message}\033[{cls.default_foreground_color}m"
+                    cls.print(
+                        f"\033[{cls.send_color}m{message}\033[{cls.default_foreground_color}m\n",
+                        end="",
                     )
 
     @classmethod
@@ -267,17 +316,22 @@ class log:
         message: object,
         /,
         *fmt_args: object,
+        stream: TextIO = sys.stderr,
+        print_level: LogLevel = LogLevel.debug,
+        write_level: LogLevel = LogLevel.debug,
         is_format: bool = True,
         deep: bool = False,
         mode: LogMode = LogMode.normal,
-        level: LogLevel = LogLevel.debug,
         **fmt_kwargs: object,
-    ):
+    ) -> None:
         cls._do_log(
-            level,
+            log.LogLevel.debug,
             mode,
             message,
             *fmt_args,
+            stream=stream,
+            print_level=print_level,
+            write_level=write_level,
             is_format=is_format,
             is_deep=deep,
             is_server=False,
@@ -291,17 +345,22 @@ class log:
         message: object,
         /,
         *fmt_args: object,
+        stream: TextIO = sys.stderr,
+        print_level: LogLevel = LogLevel.info,
+        write_level: LogLevel = LogLevel.info,
         is_format: bool = True,
         deep: bool = False,
         mode: LogMode = LogMode.normal,
-        level: LogLevel = LogLevel.info,
         **fmt_kwargs: object,
-    ):
+    ) -> None:
         cls._do_log(
-            level,
+            log.LogLevel.info,
             mode,
             message,
             *fmt_args,
+            stream=stream,
+            print_level=print_level,
+            write_level=write_level,
             is_format=is_format,
             is_deep=deep,
             is_server=False,
@@ -315,17 +374,22 @@ class log:
         message: object,
         /,
         *fmt_args: object,
+        stream: TextIO = sys.stderr,
+        print_level: LogLevel = LogLevel.warning,
+        write_level: LogLevel = LogLevel.warning,
         is_format: bool = True,
         deep: bool = False,
         mode: LogMode = LogMode.normal,
-        level: LogLevel = LogLevel.warning,
         **fmt_kwargs: object,
-    ):
+    ) -> None:
         cls._do_log(
-            level,
+            log.LogLevel.warning,
             mode,
             message,
             *fmt_args,
+            stream=stream,
+            print_level=print_level,
+            write_level=write_level,
             is_format=is_format,
             is_deep=deep,
             is_server=False,
@@ -333,23 +397,30 @@ class log:
             **fmt_kwargs,
         )
 
+    warn = warning
+
     @classmethod
     def error(
         cls,
         message: object,
         /,
         *fmt_args: object,
+        stream: TextIO = sys.stderr,
+        print_level: LogLevel = LogLevel.error,
+        write_level: LogLevel = LogLevel.error,
         is_format: bool = True,
         deep: bool = False,
         mode: LogMode = LogMode.normal,
-        level: LogLevel = LogLevel.error,
         **fmt_kwargs: object,
-    ):
+    ) -> None:
         cls._do_log(
-            level,
+            log.LogLevel.error,
             mode,
             message,
             *fmt_args,
+            stream=stream,
+            print_level=print_level,
+            write_level=write_level,
             is_format=is_format,
             is_deep=deep,
             is_server=False,
@@ -357,24 +428,31 @@ class log:
             **fmt_kwargs,
         )
 
+    err = error
+
     @classmethod
     def send(
         cls,
         message: object,
         /,
         *fmt_args: object,
+        stream: TextIO = sys.stdout,
+        print_level: LogLevel = LogLevel.send,
+        write_level: LogLevel = LogLevel.send,
         is_format: bool = True,
         mode: LogMode = LogMode.normal,
         is_server: bool = False,
         http_send_header: str = "",
-        level: LogLevel = LogLevel.send,
         **fmt_kwargs: object,
-    ):
+    ) -> None:
         cls._do_log(
-            level,
+            log.LogLevel.send,
             mode,
             message,
             *fmt_args,
+            stream=stream,
+            print_level=print_level,
+            write_level=write_level,
             is_format=is_format,
             is_deep=False,
             is_server=is_server,
@@ -386,7 +464,7 @@ class log:
     def write_html_log(
         cls,
         message: str,
-    ):
+    ) -> None:
         try:
             with open(cls.html_filename, "at", encoding="utf-8") as f:
                 f.write(message)