shenjack
8709286da5
算了，不需要 init sub modules 我的问题，没处理好依赖 some fix to make ruff happy remove ruff format looks better try try on action again!
233 lines
9.3 KiB
Python
233 lines
9.3 KiB
Python
# -------------------------------
|
||
# 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()
|