# ------------------------------- # 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()