feat: 进一步改进

src/heurams/utils/README.md

@@ -1,2 +0,0 @@
-# Utils - 实用工具
-脚本与部分分离式工具函数

src/heurams/utils/evalizor.py

@@ -0,0 +1,28 @@
+
+from typing import Any
+
+
+class Evalizer():
+    def __init__(self, environment: dict) -> None:
+        self.env = environment
+    
+    def __call__(self, *args: Any, **kwds: Any) -> Any:
+        
+
+def do_eval(self):
+    """
+    执行并以结果替换当前单元的所有 eval 语句
+    TODO: 带有限制的 eval, 异步/多线程执行避免堵塞
+    """
+
+    # eval 环境设置
+    def eval_with_env(s: str):
+        default = config_var.get()["puzzles"]
+        payload = self.registry["nucleon"].payload
+        metadata = self.registry["nucleon"].metadata
+        eval_value = eval(s)
+        if isinstance(eval_value, (int, float)):
+            ret = str(eval_value)
+        else:
+            ret = eval_value
+        return ret

src/heurams/utils/lict.py

@@ -0,0 +1,116 @@
+
+from collections import UserList
+from typing import Any
+
+class Lict(UserList): #TODO: 优化同步(惰性同步), 当前性能为 O(n)
+    """"列典" 对象  
+    同时兼容字典和列表大多数 API, 两边数据同步的容器  
+    列表数据是 dictobj.items() 的格式  
+    支持根据字典或列表初始化
+    限制要求:
+    - 键名一定唯一, 且仅能为字符串
+    - 值一定是引用对象
+    - 不使用并发
+    - 不在乎列表顺序语义(严格按键名字符序排列)和列表索引查找, 因此外部的 sort, index 等功能不可用
+    - append 的元组中, 表示键名的元素不能重复, 否则会导致覆盖行为
+    """
+    def __init__(self, initlist = None, initdict = None):
+        self.dicted_data = {}
+        if initdict != None:
+            initlist = list(initdict.items())
+        super().__init__(initlist=initlist)
+        self._sync_based_on_list()
+        self.data.sort()
+    
+    def _sync_based_on_dict(self):
+        self.data = list(self.dicted_data.items())
+        self.data.sort()
+
+    def _sync_based_on_list(self):
+        self.dicted_data = {}
+        for i in self.data:
+            self.dicted_data[i[0]] = i[1]
+
+    def __getitem__(self, i):
+        if isinstance(i, str):
+            return self.dicted_data[i]
+        else:
+            return super().__getitem__(i)
+    
+    def __setitem__(self, i, item):
+        if isinstance(i, str):
+            self.dicted_data[i] = item
+            self._sync_based_on_dict()
+        else:
+            if item != (item[0], item[1]):
+                raise NotImplementedError
+            super().__setitem__(i, item)
+            self._sync_based_on_list()
+    
+    def __delitem__(self, i):
+        if isinstance(i, str):
+            del self.dicted_data[i]
+            self._sync_based_on_dict()
+        else:
+            super().__delitem__(i)
+            self._sync_based_on_list()
+
+    def __contains__(self, item):
+        return (item in self.data or item in self.keys() or item in self.values())
+
+    def append(self, item: Any) -> None:
+        if item != (item[0], item[1]):
+            raise NotImplementedError
+        super().append(item)
+        self._sync_based_on_list()
+    
+    def insert(self, i: int, item: Any) -> None:
+        if item != (item[0], item[1]): # 确保 item 是遵从限制的元组
+            raise NotImplementedError
+        super().insert(i, item)
+        self._sync_based_on_list()
+    
+    def pop(self, i: int = -1) -> Any:
+        res = super().pop(i)
+        self._sync_based_on_list()
+        return res
+    
+    def remove(self, item: Any) -> None:
+        if isinstance(item, str):
+            item = (item, self.dicted_data[item])
+        if item != (item[0], item[1]):
+            raise NotImplementedError
+        super().remove(item)
+        self._sync_based_on_list()
+    
+    def clear(self) -> None:
+        super().clear()
+        self._sync_based_on_list()
+    
+    def index(self):
+        raise NotImplementedError
+    
+    def extend(self):
+        raise NotImplementedError
+    
+    def sort(self):
+        raise NotImplementedError
+    
+    def reverse(self):
+        raise NotImplementedError
+
+    def keys(self):
+        return self.dicted_data.keys()
+    
+    def values(self):
+        return self.dicted_data.values()
+    
+    def items(self):
+        return self.data
+
+    def keys_equal_with(self, other):
+        return self.key_equality(self, other)
+
+    @classmethod
+    def key_equality(cls, a, b):
+        return a.keys() == b.keys()