Difficult-Rocket/Difficult_Rocket/utils/translate.py

#  -------------------------------
#  Difficult Rocket
#  Copyright © 2020-2023 by shenjackyuanjie 3695888@qq.com
#  All rights reserved
#  -------------------------------

"""
writen by shenjackyuanjie <3695888@qq.com>
mail:   3695888@qq.com
github: @shenjackyuanjie
gitee:  @shenjackyuanjie
"""

import os
import inspect

from pathlib import Path
from dataclasses import dataclass
from typing import Union, Tuple, Any, List, Dict, Hashable, Optional

from Difficult_Rocket import DR_status
from Difficult_Rocket.utils import tools
from Difficult_Rocket.runtime import DR_runtime
from Difficult_Rocket.exception.language import LanguageNotFound, TranslateKeyNotFound


@dataclass
class TranslateConfig:
    raise_error: bool = False  # 引用错误时抛出错误
    crack_normal: bool = True  # 出现错误引用后 将引用到的正确内容替换为引用路径
    insert_crack: bool = True  # 加入引用的错误内容
    is_final: bool = False  # 是否为最终内容
    keep_get: bool = True  # 引用错误后是否继续引用
    always_copy: bool = False  # 是否一直新建 Translate (为 True 会降低性能)
    source: Optional[Union["Tr", "Translates"]] = None  # 翻译来源 (用于默认翻译)

    def set(self, item: str, value: Union[bool, "Tr", "Translates"]) -> "TranslateConfig":
        assert (
                getattr(self, item, None) is not None
        ), f"Config {item} is not in TranslateConfig"
        assert isinstance(value, bool)
        setattr(self, item, value)
        return self

    def __copy__(self) -> "TranslateConfig":
        return TranslateConfig(
            raise_error=self.raise_error,
            crack_normal=self.crack_normal,
            insert_crack=self.insert_crack,
            is_final=self.is_final,
            keep_get=self.keep_get,
            always_copy=self.always_copy,
            source=self.source,
        )

    def copy(self) -> "TranslateConfig":
        return self.__copy__()


key_type = Union[str, int, Hashable]


class Translates:
    def __init__(
            self,
            value: Union[Dict[str, Any], list, tuple, str],
            config: Optional[TranslateConfig] = None,
            get_list: Optional[List[Tuple[bool, str]]] = None,
    ):
        """一个用于翻译的东西
        :param value: 翻译键节点
        :param config: 配置
        :param get_list: 获取列表
        """
        self._value: Union[Dict[str, Any], list, tuple] = value
        self._config = config or TranslateConfig()
        self._get_list = get_list or []

    def set_conf_(
            self,
            option: Union[str, TranslateConfig],
            value: Optional[Union[bool, List[str]]] = None,
    ) -> "Translates":
        assert isinstance(option, (TranslateConfig, str))
        if isinstance(option, TranslateConfig):
            self._config = option
            return self
        self._config.set(option, value)
        return self

    def _raise_no_value(self, e: Exception, item: key_type):
        if self._config.raise_error:
            raise TranslateKeyNotFound(
                self._value, [x[1] for x in self._get_list]
            ) from None
        elif DR_status.report_translate_not_found:
            frame = inspect.currentframe()
            if frame is not None:
                frame = frame.f_back.f_back
                code_list = [
                    self.__getitem__.__code__,
                    self.__getattr__.__code__,
                    self.__copy__.__code__,
                    self.copy.__code__,
                    Tr.lang.__code__,
                    Tr.__getitem__.__code__,
                    Tr.__call__.__code__,
                ]  # 调用堆栈上的不需要的东西
                while True:
                    if frame.f_code not in code_list:  # 直到调用堆栈不是不需要的东西
                        break
                    frame = frame.f_back  # 继续向上寻找
                frame = f"call at {frame.f_code.co_filename}:{frame.f_lineno}"
            else:
                frame = "but No Frame environment"
            raise_info = f"{self.name} Cause a error when getting {item} {frame}"
            print(raise_info)

    def __getitem__(
            self, item: Union[key_type, List[key_type], Tuple[key_type]]
    ) -> "Translates":
        try:
            if isinstance(item, (str, int, Hashable)):
                cache_value = self._value[item]
            else:
                cache_value = self._value
                for a_item in item:
                    cache_value = cache_value[a_item]
            if isinstance(
                    cache_value,
                    (
                            int,
                            str,
                    ),
            ):
                self._config.is_final = True
            self._get_list.append((True, item))
            if self._config.always_copy:
                return Translates(
                    value=cache_value, config=self._config, get_list=self._get_list
                )
            self._value = cache_value
        except (KeyError, TypeError, AttributeError) as e:
            self._get_list.append((False, item))
            self._raise_no_value(e, item)
            if not self._config.keep_get:
                self._config.is_final = True
        return self

    def __call__(self, *args, **kwargs) -> str:
        return str(self)

    def copy(self):
        return self.__copy__()

    def __copy__(self) -> "Translates":
        return Translates(value=self._value, config=self._config, get_list=self._get_list)

    def __getattr__(self, item: key_type) -> "Translates":
        if (self._config.is_final or any(x[0] for x in self._get_list)) and hasattr(
                self._value, item
        ):
            return getattr(self._value, item)
        # 实际上我这里完全不需要处理正常需求，因为 __getattribute__ 已经帮我处理过了
        return self.__getitem__(item)

    def __str__(self):
        if not any(not x[0] for x in self._get_list):
            return str(self._value)
        if self._config.crack_normal:
            return f'{".".join(f"{gets[1]}({gets[0]})" for gets in self._get_list)}'
        elif self._config.insert_crack:
            return f'{self._value}.{".".join(gets[1] for gets in self._get_list if not gets[0])}'
        return str(self._value)


class Tr:
    """
    我不装了，我就抄了tr(实际上没啥关系)
    GOOD
    """

    def __init__(
            self,
            language: str = None,
            config: Optional[TranslateConfig] = None,
            lang_path: Optional[Path] = None,
    ):
        """
        诶嘿，我抄的MCDR
        :param language: Tr 所使用的的语言
        :param config: 配置
        :param lang_path: 语言文件夹路径
        """
        self.language_name = language if language is not None else DR_runtime.language
        self.language_path = lang_path if lang_path is not None else Path("assets/lang")
        self.translates: Dict[str, Union[str, Dict]] = tools.load_file(
            self.language_path / f"{self.language_name}.toml"
        )
        self.default_translate: Dict = tools.load_file(
            f"{self.language_path}/{DR_status.default_language}.toml"
        )
        self.default_config = (
            config.set("source", self)
            if config is not None
            else TranslateConfig(source=self)
        )
        self.translates_cache = Translates(
            value=self.translates, config=self.default_config.copy()
        )

    @property
    def _language(self) -> str:
        return self.language_name

    @_language.setter
    def _language(self, value: str):
        self.init_translate(value)

    def init_translate(self, lang: Optional[str] = None) -> bool:
        """
        初始化语言文件
        :param lang: 要初始化的语言
        :return:
        """
        # 首先判定是否存在对应的语言文件
        if lang == self.language_name:
            return False
        if lang == " " or lang == "":
            raise LanguageNotFound("Can not be empty")
        lang = lang or self.language_name
        if not os.path.exists(f"{self.language_path}/{lang}.toml"):
            print(
                f"lang: {os.path.exists(f'{self.language_path}/{lang}.toml')} language = {lang} {self.language_name=}"
            )
            raise LanguageNotFound(lang)
        self.translates: Dict[str, Union[str, Dict]] = tools.load_file(
            f"{self.language_path}/{lang}.toml"
        )
        self.default_translate: Dict = tools.load_file(
            f"{self.language_path}/{DR_runtime.default_language}.toml"
        )
        self.translates_cache = Translates(
            value=self.translates, config=self.default_config.copy()
        )
        self.language_name = lang
        DR_runtime.language = self.language_name
        return True

    def update_lang(self) -> bool:
        if DR_runtime.language != self.language_name:
            self.language_name = DR_runtime.language
            self.init_translate()
            return True
        return False

    def default(self, items: Union[str, List[str]]) -> Translates:
        if isinstance(items, list):
            cache_translate = self.default_translate
            for item in items:
                cache_translate = cache_translate[item]
            return cache_translate
        else:
            return self.default_translate[items]

    def lang(self, *items) -> Translates:
        cache = self.translates_cache.copy()
        for item in items:
            cache = cache[item]
        return cache

    def __getitem__(self, item: Union[str, int]) -> Translates:
        return self.translates_cache.copy()[item]

    def __call__(self, *args, **kwargs) -> Translates:
        return self.translates_cache.copy()


tr = Tr()