加强了部分数据管理模块的类型安全

Author: yudonglin

linpg/abstracts/__init__.py

@@ -0,0 +1,6 @@
+"""
+结构:
+getter -> setter
+"""
+
+from .setter import *

linpg/abstracts/getter.py

@@ -0,0 +1,112 @@
+import copy
+from functools import reduce
+from operator import getitem
+from typing import Any, Final, Optional, Sequence
+
+from ..exception import EXCEPTION
+
+
+class TypeSafeGetter:
+
+    __RETURN_NONE_FOR_KEY_ERROR: Final[str] = "<!RETURN_NONE_FOR_KEY_ERROR>"
+
+    # 根据keys查找值，最后返回一个复制的对象
+    @classmethod
+    def get_by_keys(cls, _dict: dict, _keys: Sequence, _default: Optional[Any] = None, _deepcopy: bool = True) -> Any:
+        try:
+            return copy.deepcopy(reduce(getitem, _keys, _dict)) if _deepcopy is True else reduce(getitem, _keys, _dict)
+        except KeyError:
+            if _default is None:
+                EXCEPTION.fatal('Getting "KeyError" while trying to get keys {} from dict!'.format(_keys))
+            return _default if _default is not cls.__RETURN_NONE_FOR_KEY_ERROR else None
+
+    # 获取static数据字典 (子类需实现)
+    @classmethod
+    def _get_data(cls) -> dict:
+        raise EXCEPTION.fatal("_get_data()", 1)
+
+    # 获取特定的数据
+    @classmethod
+    def get(cls, *_key: Any, _deepcopy: bool = True) -> Any:
+        return cls.get_by_keys(cls._get_data(), _key, _deepcopy)
+
+    # 尝试获取特定的数据
+    @classmethod
+    def try_get(cls, *_key: Any, _default: Optional[Any] = None) -> Optional[Any]:
+        return cls.get_by_keys(cls._get_data(), _key, _default)
+
+    # 是否值存在且不为None
+    @classmethod
+    def exists_not_none(cls, *_key: Any) -> bool:
+        return cls.try_get(*_key, _default=cls.__RETURN_NONE_FOR_KEY_ERROR) is not None
+
+    # 以str的形式获取特定的数据
+    @classmethod
+    def get_str(cls, *_key: Any) -> str:
+        return str(cls.get(*_key))
+
+    # 尝试以str的形式获取特定的数据
+    @classmethod
+    def try_get_str(cls, *_key: Any) -> Optional[str]:
+        _temp: Optional[Any] = cls.try_get(*_key, _default=cls.__RETURN_NONE_FOR_KEY_ERROR)
+        return str(_temp) if _temp is not None else _temp
+
+    # 以int的形式获取特定的数据
+    @classmethod
+    def get_int(cls, *_key: Any) -> int:
+        return int(cls.get(*_key))
+
+    # 尝试以int的形式获取特定的数据
+    @classmethod
+    def try_get_int(cls, *_key: Any) -> Optional[int]:
+        _temp: Optional[Any] = cls.try_get(*_key, _default=cls.__RETURN_NONE_FOR_KEY_ERROR)
+        return int(_temp) if _temp is not None else _temp
+
+    # 以bool的形式获取特定的数据
+    @classmethod
+    def get_bool(cls, *_key: Any) -> bool:
+        return bool(cls.get(*_key))
+
+    # 尝试以bool的形式获取特定的数据
+    @classmethod
+    def try_get_bool(cls, *_key: Any) -> Optional[bool]:
+        _temp: Optional[Any] = cls.try_get(*_key, _default=cls.__RETURN_NONE_FOR_KEY_ERROR)
+        return bool(_temp) if _temp is not None else _temp
+
+    # 以dict的形式获取特定的数据
+    @classmethod
+    def get_dict(cls, *_key: Any) -> dict:
+        return dict(cls.get(*_key))
+
+    # 以dict的形式获取特定的数据（不复制）
+    @classmethod
+    def get_dict_ref(cls, *_key: Any) -> dict:
+        return dict(cls.get(*_key, _deepcopy=False))
+
+    # 尝试以dict的形式获取特定的数据
+    @classmethod
+    def try_get_dict(cls, *_key: Any) -> Optional[dict]:
+        _temp: Optional[Any] = cls.try_get(*_key, _default=cls.__RETURN_NONE_FOR_KEY_ERROR)
+        return dict(_temp) if _temp is not None else _temp
+
+    # 以list的形式获取特定的数据
+    @classmethod
+    def get_list(cls, *_key: Any) -> list:
+        return list(cls.get(*_key))
+
+    # 尝试以list的形式获取特定的数据
+    @classmethod
+    def try_get_list(cls, *_key: Any) -> Optional[list]:
+        _temp: Optional[Any] = cls.try_get(*_key, _default=cls.__RETURN_NONE_FOR_KEY_ERROR)
+        return list(_temp) if _temp is not None else _temp
+
+    # 以tuple的形式获取特定的数据
+    @classmethod
+    def get_tuple(cls, *_key: Any) -> tuple:
+        return tuple(cls.get(*_key))
+
+    # 尝试以tuple的形式获取特定的数据
+    @classmethod
+    def try_get_tuple(cls, *_key: Any) -> Optional[tuple]:
+        _temp: Optional[Any] = cls.try_get(*_key, _default=cls.__RETURN_NONE_FOR_KEY_ERROR)
+        return tuple(_temp) if _temp is not None else _temp

linpg/abstracts/setter.py

@@ -0,0 +1,39 @@
+from .getter import *
+
+
+class TypeSafeSetter:
+
+    # 根据keys查找被设置对应对应对象为指定值
+    @staticmethod
+    def set_by_keys(_dict: dict, _keys: Sequence, value: object, assumeKeyExists: bool = True) -> None:
+        if len(_keys) < 1:
+            EXCEPTION.fatal("Keys' length has to be greater than 0.")
+        pointer: dict = _dict
+        last_key_index: int = len(_keys) - 1
+        for index in range(last_key_index):
+            _item: Optional[object] = pointer.get(_keys[index])
+            if isinstance(_item, dict):
+                pointer = _item
+            elif _item is None:
+                if assumeKeyExists is True:
+                    EXCEPTION.fatal('Getting "KeyError" while trying to set keys {} to dict!'.format(_keys))
+                pointer[_keys[index]] = {}
+                pointer = pointer[_keys[index]]
+            else:
+                EXCEPTION.fatal("Getting not dict object {0} while trying to set keys {1} to dict!".format(_item, _keys))
+        pointer[_keys[last_key_index]] = value
+
+    # 获取static数据字典 (子类需实现)
+    @classmethod
+    def _get_data(cls) -> dict:
+        raise EXCEPTION.fatal("_get_data()", 1)
+
+    # 设置特定的数据
+    @classmethod
+    def set(cls, *_key: str, value: Any, assumeKeyExists: bool = True) -> None:
+        cls.set_by_keys(cls._get_data(), _key, value, assumeKeyExists)
+
+    # 清空所有数据（谨慎使用）
+    @classmethod
+    def clear(cls) -> None:
+        cls._get_data().clear()

linpg/basic/saves.py

@@ -4,18 +4,18 @@
 from .font import *
 
 # 持久数据管理IO
-class PersistentData:
+class PersistentData(TypeSafeGetter, TypeSafeSetter):
 
     __DATA: Final[dict[str, Any]] = {}
     __PATH: Final[str] = Specification.get_directory("save", "persistent." + Config.get_file_type())
 
     @classmethod
-    def get(cls, *_keys: str, _default: Optional[Any] = None) -> Any:
-        return get_value_by_keys(cls.__DATA, _keys, _default)
+    def _get_data(cls) -> dict:
+        return cls.__DATA
 
     @classmethod
-    def set(cls, *_keys: str, value: object) -> None:
-        set_value_by_keys(cls.__DATA, _keys, value, False)
+    def set(cls, *_key: str, value: Any, assumeKeyExists: bool = False) -> None:
+        super().set(*_key, value=value, assumeKeyExists=assumeKeyExists)
         cls.save()
 
     @classmethod

linpg/config/__init__.py

@@ -1,5 +1,5 @@
 """
 结构:
-base -> setting -> modules -> data
+base -> setting -> modules
 """
-from .data import *
+from .modules import *

linpg/config/base.py

@@ -1,10 +1,7 @@
-import copy
 import json
-from functools import reduce
 from glob import glob
-from operator import getitem
-from typing import Any, Final, Optional, Sequence
 
+from ..abstracts import *
 from ..exception import EXCEPTION, os
 
 # 尝试导入yaml库
@@ -16,37 +13,6 @@
 except Exception:
     pass
 
-
-# 根据keys查找值，最后返回一个复制的对象
-def get_value_by_keys(_dict: dict, _keys: Sequence, _default: Optional[Any] = None) -> Any:
-    try:
-        return copy.deepcopy(reduce(getitem, _keys, _dict))
-    except KeyError:
-        if _default is None:
-            EXCEPTION.fatal('Getting "KeyError" while trying to get keys {} from dict!'.format(_keys))
-        return _default
-
-
-# 根据keys查找被设置对应对应对象为指定值
-def set_value_by_keys(_dict: dict, _keys: Sequence, value: object, assumeKeyExists: bool = True) -> None:
-    if len(_keys) < 1:
-        EXCEPTION.fatal("Keys' length has to be greater than 0.")
-    pointer: dict = _dict
-    last_key_index: int = len(_keys) - 1
-    for index in range(last_key_index):
-        _item: Optional[object] = pointer.get(_keys[index])
-        if isinstance(_item, dict):
-            pointer = _item
-        elif _item is None:
-            if assumeKeyExists is True:
-                EXCEPTION.fatal('Getting "KeyError" while trying to set keys {} to dict!'.format(_keys))
-            pointer[_keys[index]] = {}
-            pointer = pointer[_keys[index]]
-        else:
-            EXCEPTION.fatal("Getting not dict object {0} while trying to set keys {1} to dict!".format(_item, _keys))
-    pointer[_keys[last_key_index]] = value
-
-
 # 配置文件管理模块
 class Config:
 
@@ -93,7 +59,7 @@ def try_load_file_if_exists(cls, _path: str, _default: dict = {}) -> dict:
     # 加载配置文件，并根据key（s）返回对应的数据
     @classmethod
     def load(cls, path: str, *key: str) -> Any:
-        return get_value_by_keys(cls.__load_file(path), key)
+        return TypeSafeGetter.get_by_keys(cls.__load_file(path), key)
 
     # 加载内部配置文件
     @classmethod
@@ -147,16 +113,60 @@ def resolve_path_and_load_file(cls, file_location: str) -> dict:
 
 
 # 使用引擎的开发者可以自定义的参数
-class Specification:
+class Specification(TypeSafeGetter):
 
     __SPECIFICATIONS: Final[dict] = Config.load_internal_file("specifications.json")
     # 尝试加载项目自定义的参数
     __SPECIFICATIONS.update(Config.resolve_path_and_load_file(os.path.join("Data", "specifications")))
 
     @classmethod
-    def get(cls, *key: str) -> Any:
-        return get_value_by_keys(cls.__SPECIFICATIONS, key)
+    def _get_data(cls) -> dict:
+        return cls.__SPECIFICATIONS
 
     @classmethod
     def get_directory(cls, category: str, *_sub: str) -> str:
         return str(os.path.join(*cls.__SPECIFICATIONS["Directory"][category], *_sub))
+
+
+# 数据库
+class DataBase(TypeSafeGetter):
+
+    # 用于存放数据库数据的字典
+    __DATA_BASE_DICT: Final[dict] = {"Tiles": {}, "Decorations": {}, "Npc": {}, "Filters": {}}
+
+    @classmethod
+    def _get_data(cls) -> dict:
+        return cls.__DATA_BASE_DICT
+
+    @classmethod
+    def update(cls, _value: dict) -> None:
+        for key, value in _value.items():
+            if key not in cls.__DATA_BASE_DICT:
+                cls.__DATA_BASE_DICT[key] = value
+            else:
+                cls.__DATA_BASE_DICT[key].update(value)
+
+
+# 全局数据
+class GlobalVariables(TypeSafeGetter, TypeSafeSetter):
+
+    # 用于存放全局数据的字典
+    __GLOBAL_VARIABLES_DICT: Final[dict] = {}
+
+    @classmethod
+    def _get_data(cls) -> dict:
+        return cls.__GLOBAL_VARIABLES_DICT
+
+    # 删除特定的全局数据
+    @classmethod
+    def remove(cls, _key: str) -> None:
+        cls.__GLOBAL_VARIABLES_DICT.pop(_key, None)
+
+    # 如果不是对应的值，则设置为对应的值，返回是否对应
+    @classmethod
+    def if_get_set(cls, _key: str, valueToGet: object, valueToSet: object) -> bool:
+        if cls.__GLOBAL_VARIABLES_DICT[_key] == valueToGet:
+            cls.__GLOBAL_VARIABLES_DICT[_key] = valueToSet
+            return True
+        else:
+            return False