kevin-toolbox-dev 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.1.1"
+__version__ = "1.1.3"
 
 
 import os
@@ -12,5 +12,5 @@ os.system(
 os.system(
     f'python {os.path.split(__file__)[0]}/env_info/check_validity_and_uninstall.py '
     f'--package_name kevin-toolbox-dev '
-    f'--expiration_timestamp 1702873414 --verbose 0'
+    f'--expiration_timestamp 1703667553 --verbose 0'
 )

kevin_toolbox/computer_science/algorithm/for_nested_dict_list/copy_.py

@@ -16,7 +16,8 @@ def copy_(var, b_deepcopy=False):
         return copy.deepcopy(var)
 
     return traverse(var=[var], match_cond=lambda _, __, value: isinstance(value, (list, dict,)),
-                    action_mode="replace", converter=lambda _, value: value.copy(), b_traverse_matched_element=True)[0]
+                    action_mode="replace", converter=lambda _, value: value.copy(),
+                    traversal_mode="dfs_pre_order", b_traverse_matched_element=True)[0]
 
 
 if __name__ == '__main__':

kevin_toolbox/computer_science/algorithm/for_nested_dict_list/get_value_by_name.py

@@ -1,7 +1,7 @@
 from kevin_toolbox.computer_science.algorithm.for_nested_dict_list.name_handler import parse_name
 
 
-def get_value_by_name(var, name):
+def get_value_by_name(var, name, b_pop=False, **kwargs):
     """
         通过解释名字得到取值方式，然后到 var 中获取对应部分的值。
 
@@ -13,18 +13,36 @@ def get_value_by_name(var, name):
                                     ":acc@1" 或者 "|acc|1" 等。
                                 注意，在 name 的开头也可以添加任意非解释方式的字符，本函数将直接忽略它们，比如下面的:
                                     "var:acc@1" 和 "xxxx|acc|1" 也能正常读取。
+            b_pop:          <boolean> 是否将值从 var 中移除
+                                默认为 False
+            default:        默认值
+                                - 不设置（默认）。当取值失败时将报错。
+                                - 设置为任意值。取值失败时将返回该值。
     """
     _, method_ls, node_ls = parse_name(name=name, b_de_escape_node=True)
 
-    for method, node in zip(method_ls, node_ls):
-        if method == "@":
-            var = var[eval(node)]
-        elif method == "|":
-            try:
-                var = var[node]
-            except:
-                var = var[eval(node)]
-        else:  # ":"
-            var = var[node]
+    try:
+        pre, cur = None, var
+        node = None
+        for method, node in zip(method_ls, node_ls):
+            pre, cur = cur, None
+            if method == "@":
+                node = eval(node)
+            elif method == "|":
+                try:
+                    _ = pre[node]
+                except:
+                    node = eval(node)
+            cur = pre[node]
 
-    return var
+        if b_pop and len(node_ls) > 0:
+            assert isinstance(pre, (dict, list,)), \
+                f'pop is only supported when the parent node type is list or dict, but got a {type(pre)}'
+            pre.pop(node)
+    except:
+        if "default" in kwargs:
+            cur = kwargs["default"]
+        else:
+            raise IndexError(f'invalid name {name}')
+
+    return cur

kevin_toolbox/computer_science/algorithm/for_nested_dict_list/set_value_by_name.py

@@ -16,7 +16,7 @@ def set_value_by_name(var, name, value, b_force=False):
                                     "var:acc@1" 和 "xxxx|acc|1" 也能正常写入。
             value:          待赋给的值
             b_force:        <boolean> 当无法设置时，是否尝试创建或者修改节点
-                                默认为 False，
+                                默认为 False，此时若无法设置，则报错
                                 当设置为 True，可能会对 var 的结构产生不可逆的改变，请谨慎使用。
                                     - 根据取值方式的不同，新创建或者修改的节点的类型可能是 dict 或者 list，
                                         对于 list，其中缺省值填充 None。

kevin_toolbox/computer_science/algorithm/for_nested_dict_list/traverse.py

@@ -1,8 +1,21 @@
+from enum import Enum
 from kevin_toolbox.computer_science.algorithm.for_nested_dict_list.name_handler import escape_node
 
 
+class ACTION_MODE(Enum):
+    remove = 1
+    replace = 2
+    skip = 3
+
+
+class TRAVERSAL_MODE(Enum):
+    dfs_pre_order = 1
+    dfs_post_order = 2
+    bfs = 3
+
+
 def traverse(var, match_cond, action_mode="remove", converter=None,
-             b_use_name_as_idx=False, b_traverse_matched_element=False):
+             b_use_name_as_idx=False, traversal_mode="dfs_pre_order", b_traverse_matched_element=False):
     """
         遍历 var 找到符合 match_cond 的元素，将其按照 action_mode 指定的操作进行处理
 
@@ -27,43 +40,109 @@ def traverse(var, match_cond, action_mode="remove", converter=None,
             converter:          <func> 参见 action_mode 中的 "replace" 模式
                                     函数类型为 def(idx, value): ...
                                     其中 idx 和 value 的含义参见参数 match_cond 介绍
+            traversal_mode:     <str> 遍历的模式、顺序
+                                    目前支持：
+                                        "dfs_pre_order"         深度优先、先序遍历
+                                        "dfs_post_order"        深度优先、后序遍历
+                                        "bfs"                   宽度优先
+                                    默认为 "dfs_pre_order"
             b_use_name_as_idx:  <boolean> 对于 match_cond/converter 中的 idx 参数，是传入整体的 name 还是父节点的 index 或 key。
                                     默认为 False
             b_traverse_matched_element  <boolean> 对于匹配上的元素，经过处理后，是否继续遍历该元素的内容
                                     默认为 False
     """
     assert callable(match_cond)
-    assert action_mode in {"replace", "remove", "skip"}
-    if action_mode == "replace":
+    assert action_mode in ACTION_MODE.__members__.keys()
+    action_mode = ACTION_MODE.__members__[action_mode]
+    if action_mode is ACTION_MODE.replace:
         assert callable(converter)
+    #
+    assert traversal_mode in TRAVERSAL_MODE.__members__.keys()
+    traversal_mode = TRAVERSAL_MODE.__members__[traversal_mode]
 
-    return recursive_(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element, "")
+    if traversal_mode is TRAVERSAL_MODE.bfs:
+        return _bfs(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element)
+    else:
+        return _dfs(var, match_cond, action_mode, converter, b_use_name_as_idx, traversal_mode,
+                    b_traverse_matched_element, "")
+
+
+def _bfs(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element):
+    temp = [("", var)]
 
+    while len(temp):
+        pre_name, i = temp.pop(0)
+        if isinstance(i, (list, dict)):
+            keys = list(range(len(i)) if isinstance(i, list) else i.keys())
+            keys.reverse()  # 反过来便于 列表 弹出元素
+            idx_ls = _gen_idx(i, keys, b_use_name_as_idx, pre_name)
 
-def recursive_(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element, pre_name):
+            # 匹配&处理
+            for k, idx in zip(keys, idx_ls):
+                b_matched, b_popped = _deal(i, k, idx, match_cond, converter, action_mode)
+                if b_popped or (b_matched and not b_traverse_matched_element):
+                    continue
+                # 添加到队尾
+                temp.append((idx, i[k]))
+
+    return var
+
+
+def _dfs(var, match_cond, action_mode, converter,
+         b_use_name_as_idx, traversal_mode, b_traverse_matched_element, pre_name):
     if isinstance(var, (list, dict)):
-        items = reversed(list(enumerate(var))) if isinstance(var, list) else list(var.items())
-        for k, v in items:
-            if b_use_name_as_idx:
-                method = "@" if isinstance(var, list) else ":"
-                idx = f'{pre_name}{method}{escape_node(node=k, b_reversed=False, times=1)}'
-            else:
-                idx = k
-            # 匹配
-            b_matched = match_cond(type(var), idx, v)
-            # 处理
-            if b_matched:
-                if action_mode == "remove":
-                    var.pop(k)
-                elif action_mode == "replace":
-                    var[k] = converter(idx, v)
-                else:
-                    pass
+        keys = list(range(len(var)) if isinstance(var, list) else var.keys())
+        keys.reverse()  # 反过来便于 列表 弹出元素
+        idx_ls = _gen_idx(var, keys, b_use_name_as_idx, pre_name)
+
+        #
+        if traversal_mode is TRAVERSAL_MODE.dfs_pre_order:
+            # 先序
+            # 匹配&处理
+            deal_res_ls = []
+            for k, idx in zip(keys, idx_ls):
+                deal_res_ls.append(_deal(var, k, idx, match_cond, converter, action_mode))
             # 递归遍历
-            if b_matched and not b_traverse_matched_element:
-                continue
-            var[k] = recursive_(var[k], match_cond, action_mode, converter, b_use_name_as_idx,
-                                b_traverse_matched_element, idx)
+            for (b_matched, b_popped), k, idx in zip(deal_res_ls, keys, idx_ls):
+                if b_popped or (b_matched and not b_traverse_matched_element):
+                    continue
+                var[k] = _dfs(var[k], match_cond, action_mode, converter, b_use_name_as_idx, traversal_mode,
+                              b_traverse_matched_element, idx)
+        else:
+            # 后序
+            # 递归遍历
+            for k, idx in zip(keys, idx_ls):
+                var[k] = _dfs(var[k], match_cond, action_mode, converter, b_use_name_as_idx, traversal_mode,
+                              b_traverse_matched_element, idx)
+            # 匹配&处理
+            for k, idx in zip(keys, idx_ls):
+                _deal(var, k, idx, match_cond, converter, action_mode)
     else:
         pass
     return var
+
+
+def _deal(var, k, idx, match_cond, converter, action_mode):
+    """处理节点"""
+    # 匹配
+    b_matched = match_cond(type(var), idx, var[k])
+    b_popped = False
+    # 处理
+    if b_matched:
+        if action_mode is ACTION_MODE.remove:
+            var.pop(k)
+            b_popped = True
+        elif action_mode is ACTION_MODE.replace:
+            var[k] = converter(idx, var[k])
+        else:
+            pass
+    return b_matched, b_popped
+
+
+def _gen_idx(var, keys, b_use_name_as_idx, pre_name):
+    if b_use_name_as_idx:
+        method = "@" if isinstance(var, list) else ":"
+        idx_ls = [f'{pre_name}{method}{escape_node(node=k, b_reversed=False, times=1)}' for k in keys]
+    else:
+        idx_ls = keys
+    return idx_ls

kevin_toolbox/computer_science/algorithm/for_nested_dict_list/value_parser/eval_references.py

@@ -9,8 +9,12 @@ def eval_references(var, node_s, order, converter_for_ref=None, converter_for_re
             var:
             node_s:                 <dict> 引用节点，parse_references() 返回的结果
             order:                  <list of name> 计算顺序，cal_relation_between_references() 返回的结果
-            converter_for_ref:      <callable> 对引用值施加何种处理
-                                        形如 def(idx, v): ... 的函数，其中 idx 是被引用节点的名字，v是其值
+            converter_for_ref:      <callable> 对被引用节点施加何种处理
+                                        形如 def(idx, v): ... 的函数，其中 idx 是被引用节点的名字，v是其值，
+                                        返回的结果将替换掉被引用节点中原来的值。
+                                        注意：
+                                            - 处理后得到的结果将替换掉原引用节点的值。（重要所以说两次）
+                                            - 当同一节点被多次引用时，仅会被处理、替换一次。
             converter_for_res:      <callable> 对计算结果施加何种处理
                                         形如 def(idx, v): ... 的函数，其中 idx 是节点的名字，v是计算结果
     """
@@ -18,13 +22,18 @@ def eval_references(var, node_s, order, converter_for_ref=None, converter_for_re
     assert converter_for_ref is None or callable(converter_for_ref)
     assert converter_for_res is None or callable(converter_for_res)
 
+    processed_ref_nodes = set()
+
     for name in order:
         details = node_s[name]
         # 获取依赖值
-        for k, v in details["paras"].items():
-            v_new = get_value_by_name(var=var, name=v)
-            if converter_for_ref is not None:
-                v_new = converter_for_ref(v, v_new)
+        for k, idx in details["paras"].items():
+            v_new = get_value_by_name(var=var, name=idx)
+            if converter_for_ref is not None and idx not in processed_ref_nodes:
+                v_new = converter_for_ref(idx, v_new)
+                # 赋值
+                set_value_by_name(var=var, name=idx, value=v_new, b_force=False)
+                processed_ref_nodes.add(idx)
             details["paras"][k] = v_new
         # 计算
         res = eval(details["expression"], details["paras"])

kevin_toolbox/computer_science/algorithm/registration/registry.py

@@ -57,7 +57,12 @@ class Registry:
             __new__函数返回的实例，将作为self参数被传入到__init__函数。
                 如果__new__函数返回一个已经存在的实例（不论是哪个类的），__init__还是会被调用的，所以要特别注意__init__中对变量的赋值。
         """
-        uid = kwargs.get("uid", cls.__counter)
+        if "uid" in kwargs:
+            uid = kwargs["uid"]
+        else:
+            while cls.__counter in cls.__instances:
+                cls.__counter += 1
+            uid = cls.__counter
 
         # 获取实例
         if uid in cls.__instances:
@@ -72,8 +77,13 @@ class Registry:
         """
             参数：
                 uid:                <hashable> 实例的唯一标识符
-                                        默认置空，此时将新建一个实例，并将此时已有实例的数量作为 uid
-                                        当为非空，则根据 uid 到已有实例中寻找相同的实例，并返回（使用该特性可以构造单例模式）
+                                        - 不设置。新建一个实例，并自动分配一个整数作为 uid（一般是此时已有实例的数量-1），
+                                            并将该实例记录到类变量 instances_of_Registry 中。
+                                        - 设置为 None。新建一个实例，但不记录到类变量 instances_of_Registry 中。
+                                        - 设置为其他值。根据 uid 到类变量 instances_of_Registry 的已有实例中寻找相同的实例，
+                                            若命中则返回已有实例，若无则以该 uid 新建一个实例并添加到 instances_of_Registry 中。
+                                            （使用该特性可以构造单例模式）
+                                        默认为不设置。
         """
         try:
             getattr(self, "uid")
@@ -87,8 +97,8 @@ class Registry:
         self._path_to_collect = []
         self._item_to_add = []
         # 记录到 __instances 中
-        Registry.__instances[self.uid] = self
-        Registry.__counter += 1
+        if self.uid is not None:
+            Registry.__instances[self.uid] = self
 
     def add(self, obj, name=None, b_force=False, b_execute_now=True):
         """
@@ -140,7 +150,7 @@ class Registry:
                                       b_force=True)
         # check
         if not b_force:
-            inc_node_nums = fndl.count_leaf_node_nums(var=obj) if isinstance(obj, (list, dict)) else 1  # 增加的节点数量
+            inc_node_nums = fndl.count_leaf_node_nums(var=obj) if isinstance(obj, (list, dict)) else 1  # 应该增加的节点数量
             if fndl.count_leaf_node_nums(var=temp) != fndl.count_leaf_node_nums(var=self.database) + inc_node_nums:
                 # print(f'registration failed, name {name} may be a conflict with an '
                 #       f'existing member in {[i for i, j in fndl.get_nodes(var=self.database)]}')
@@ -149,13 +159,15 @@ class Registry:
         self.database = temp
         return True
 
-    def get(self, name, **kwargs):
+    def get(self, name, b_pop=False, **kwargs):
         """
             获取
 
             参数：
-                name：           <str> 成员名称
-                default:          默认值
+                name:           <str> 成员名称
+                b_pop:          <boolean> 取值的同时移除该成员
+                                    默认为 False
+                default:        默认值
                                     找不到时，若无默认值则报错，否则将返回默认值
         """
         # 加载待注册成员
@@ -168,46 +180,7 @@ class Registry:
                 self.collect_from_paths(**i)
             self._path_to_collect.clear()
 
-        try:
-            return fndl.get_value_by_name(var=self.database, name=name)
-        except:
-            if "default" in kwargs:
-                return kwargs["default"]
-            else:
-                raise AssertionError(f'element {name} not exists')
-
-    def pop(self, name, **kwargs):
-        """
-            弹出
-
-            参数：
-                name：           <str> 成员名称
-                                    名称一定要准确，不能含有模糊的 | 字符
-                default:          默认值
-                                    找不到时，若无默认值则报错，否则将返回默认值
-        """
-        assert "|" not in name, \
-            f'to pop up a specific member needs to give the exact name, ' \
-            f'does not support the "|" character with automatic deduction, invalid name: {name}, ' \
-            f'what you probably want to pop is {name.replace("|", ":")}'
-        res, b_found = None, False
-
-        def func(_, idx, value):
-            nonlocal res, b_found
-            if res is None and idx == name:
-                res, b_found = value, True
-                return True
-            else:
-                return False
-
-        fndl.traverse(var=self.database, match_cond=func, action_mode="remove", b_use_name_as_idx=True)
-        if b_found:
-            return res
-        else:
-            if "default" in kwargs:
-                return kwargs["default"]
-            else:
-                raise AssertionError(f'element {name} not exists')
+        return fndl.get_value_by_name(var=self.database, name=name, b_pop=b_pop, **kwargs)
 
     def clear(self):
         self.database.clear()
@@ -236,7 +209,7 @@ class Registry:
 
         return wrapper
 
-    # -------------------- 其他 --------------------- #
+    # -------------------- 通过路径添加 --------------------- #
 
     def collect_from_paths(self, path_ls=None, path_ls_to_exclude=None, b_execute_now=False):
         """
@@ -298,5 +271,11 @@ class Registry:
         if temp is not None:
             self.database = temp.database
 
+    # -------------------- 其他 --------------------- #
+
+    @property
+    def instances_of_Registry(self):
+        return dict(Registry.__instances)
+
 
 UNIFIED_REGISTRY = Registry(uid="UNIFIED_REGISTRY")

kevin_toolbox/computer_science/algorithm/scheduler/strategy_manager.py

@@ -2,7 +2,7 @@ import random
 import torch
 import numpy as np
 import copy
-from kevin_toolbox.computer_science.algorithm.for_nested_dict_list import set_value_by_name, get_value_by_name
+from kevin_toolbox.computer_science.algorithm.for_nested_dict_list import set_value_by_name, get_value_by_name, traverse
 
 
 class Strategy_Manager:
@@ -20,9 +20,9 @@ class Strategy_Manager:
                         ":lr": {
                             # 当 key 满足 trigger_value 时，将 ":lr" 指向的部分替换为 value
                             0: 0.1,
-                            # 如果是以 <f> 为开头的字符串，则视为函数并将 value 解释为函数执行后的结果
+                            # 如果是以 <eval> 为开头的字符串，则视为函数并将 value 解释为函数执行后的结果
                             #       函数中 t, p 参数将被分别传入 trigger_value 和 para_value
-                            "<f>lambda t: t%100==0": "<f>lambda p, t: p*0.1",
+                            "<eval>lambda t: t%100==0": "<eval>lambda p, t: p*0.1",
                         },
                     },
                     override=False,
@@ -93,10 +93,11 @@ class Strategy_Manager:
                                                 300: {
                                                     ":ratio_ls@1": 1e-5,
                                                 },  # 在 epoch=300 时，将 ratio_ls[1] 设置为 1e-5
-                                                "<f>lambda t: t%100==0": {
-                                                    ":lr": "<f>lambda p, t: p*0.1",
-                                                },  # 当键为 string 且 开头带有 <f> 标记时候，将以函数的方式读取该字符串，
-                                                    # 并在匹配过程中向该函数输入触发值 t 和当前元素的值 p，当函数返回True视为匹配成功。
+                                                "<eval>lambda t: t%100==0": {
+                                                    ":lr": "<eval>lambda p, t: p*0.1",
+                                                },  # 当键为 string 且 开头带有 <eval> 标记时候，将使用 eval() 函数读取该字符串，
+                                                    # 当键为 callable 的函数时，在匹配过程中向该函数输入触发值 t 和当前元素的值 p，
+                                                    # 当函数返回True视为匹配成功。
                                                     # 比如上式表示的是：每经过 100 epoch，也就是当 epoch%100==0 时，lr 在原来的基础上乘上0.1。
                                                     # 函数匹配的的优先级低于直接的值匹配。
                                                 ...
@@ -109,7 +110,7 @@ class Strategy_Manager:
                                                 "__trigger_name": "epoch",
                                                 ":lr": {
                                                     0: 0.1,
-                                                    "<f>lambda t: t%100==0": "<f>lambda p, t: p*0.1",
+                                                    "<eval>lambda t: t%100==0": "<eval>lambda p, t: p*0.1",
                                                 },
                                                 ":ratio_ls": {
                                                     0: [1e-3, 1e-2],
@@ -146,6 +147,21 @@ class Strategy_Manager:
                     temp[t_key][p_key] = strategy[p_key][t_key]
             strategy = temp
 
+        def deal_eval_str(x):
+            return eval(x[6:]) if isinstance(x, (str,)) and x.startswith("<eval>") else x
+
+        # 使用 eval() 读取带 "<eval>" 标签的键or值
+        def converter(_, value):
+            if isinstance(value, (dict,)):
+                res = {deal_eval_str(k): deal_eval_str(v) for k, v in value.items()}
+            else:
+                res = deal_eval_str(value)
+            return res
+
+        strategy = traverse(var=[strategy], match_cond=lambda _, __, value: isinstance(value, (dict, str,)),
+                            action_mode="replace", converter=converter, traversal_mode="dfs_post_order",
+                            b_use_name_as_idx=False, b_traverse_matched_element=True)[0]
+
         # 将策略添加到 database
         old_strategy = self.database.get(_trigger_name, dict())
         for t_key, item in strategy.items():
@@ -187,7 +203,7 @@ class Strategy_Manager:
             action_s = dict()  # {p_name: p_value, ...}
             # 使用匹配函数
             for key, p_s in strategy.items():
-                if isinstance(key, (str,)) and key.startswith("<f>") and eval(key[3:])(t_value):
+                if callable(key) and key(t_value):
                     action_s.update({i: j for i, j in p_s.items() if i not in action_s})
             # 直接匹配
             if t_value in strategy:
@@ -200,9 +216,9 @@ class Strategy_Manager:
         for t_name, action_s in sorted(action_s_all.items(), key=lambda x: x[0]):
             t_value = trigger_state[t_name]
             for name, p_value in copy.deepcopy(action_s):
-                if isinstance(p_value, (str,)) and p_value.startswith("<f>"):
+                if callable(p_value):
                     raw_value = get_value_by_name(var=var, name=name)
-                    p_value = eval(p_value[3:])(raw_value, t_value)
+                    p_value = p_value(raw_value, t_value)
                 set_value_by_name(var=var, name=name, value=p_value)
 
         return var, action_s_all
@@ -217,7 +233,7 @@ if __name__ == '__main__':
         "__trigger_name": "epoch",
         ":lr": {
             # 0: 0.1,
-            "<f>lambda t: t%100==0": "<f>lambda p, t: p*0.1",
+            "<eval>lambda t: t%100==0": "<eval>lambda p, t: p*0.1",
         },
     })
     sm.add(strategy={
@@ -230,8 +246,8 @@ if __name__ == '__main__':
         300: {
             ":ratio_ls@1": 1e-5,
         },
-        # "<f>lambda t: t%100==0": {
-        #     ":lr": "<f>lambda p, t: p*0.1",
+        # "<eval>lambda t: t%100==0": {
+        #     ":lr": "<eval>lambda p, t: p*0.1",
         # },
     }, override=False)
 

kevin_toolbox/computer_science/algorithm/scheduler/trigger.py

@@ -1,60 +1,87 @@
+import copy
+from kevin_toolbox.computer_science.algorithm.registration import Registry
+from kevin_toolbox.computer_science.algorithm import for_nested_dict_list as fndl
+
+
 class Trigger:
-    def __init__(self):
+    """
+        触发器
+            通过 self.update_by_state() 来接收并监视 state_dict，
+            当 state_dict 全部或部分发生变化时，将会把【发生变化的部分】
+            传入 self.bind() 绑定的函数中，并执行一次该函数。
+    """
+
+    def __init__(self, **kwargs):
         """
-            触发器
-                通过 self.update_by_state() 来接收并监视 state_dict，
-                当 state_dict 全部或部分发生变化时，将会把【发生变化的部分】
-                传入 self.bind() 绑定的函数中，并执行一次该函数。
+            参数：
+                target_s:           <dict> 待绑定目标
+                                        以名称 name 为键，以待绑定目标 target 为值
+                                        主要调用 self.bind()
+                init_state          <dict> 初始状态
+                                        默认不设置，此时将在第一次调用 self.update_by_state() 时设置
         """
+        # 默认参数
+        paras = {
+            #
+            "target_s": dict(),
+            "init_state": dict()
+        }
+
+        # 获取参数
+        paras.update(kwargs)
 
-        self.last_state = dict()
-        self.func_ls = []
+        self.last_state = paras["init_state"]
+        self.database = Registry(uid=None)
+        for k, v in paras["target_s"].items():
+            self.bind(name=k, target=v)
 
-    def bind_func(self, target):
+    def bind(self, name, target):
         """
-            绑定函数
+            绑定触发目标
+                触发目标有以下类型
+                - 可以是实例（要求实例具有 update_by_state() 方法，将该方法作为真正的触发目标）
+                - 函数
 
             参数：
-                target:     <func/list of func>
+                name:               <str> 名称，具体参见 for_nested_dict_list 中关于 name 的介绍
+                target:             <obj/func> 待绑定目标
         """
-        target = [target] if not isinstance(target, (list, tuple,)) else target
-        for func in target:
-            assert callable(func)
-        self.func_ls.extend(target)
+        func = getattr(target, "update_by_state", None)
+        target = target if func is None else func
+        assert callable(target), \
+            f'object {target} is not callable and has no update_by_state() method to be bound'
+        assert isinstance(name, (str,))
 
-    def bind_obj(self, target):
+        self.database.add(obj=target, name=name, b_force=True, b_execute_now=True)
+
+    def unbind(self, name, b_not_exist_ok=True):
         """
-            绑定实例
-                要求实例具有 update_by_state() 方法
+            接触绑定
 
             参数：
-                target:     <func/list of obj>
-        """
-        target = [target] if not isinstance(target, (list, tuple,)) else target
-        temp = []
-        for i in target:
-            func = getattr(i, "update_by_state", None)
-            assert callable(func), \
-                f'there is no update_by_state() method in the object {i} to be bound'
-            temp.append(func)
-        self.func_ls.extend(temp)
-
-    def bind(self, target):
-        """
-            依次尝试通过 bind_func() 和 bind_obj() 方法对 target 进行绑定
+                name:               <str> 待接触绑定目标的名称
+                b_not_exist_ok:     <boolean> name 不存在时是否不报错
+                                        默认为 True，不报错
         """
-        target = [target] if not isinstance(target, (list, tuple,)) else target
-        for i in target:
-            try:
-                self.bind_func(target=i)
-            except:
-                self.bind_obj(target=i)
-
-    def update_by_state(self, cur_state):
+
+        try:
+            self.database.get(name=name, b_pop=True)
+        except:
+            if not b_not_exist_ok:
+                raise IndexError(f'name {name} not exists')
+
+    def update_by_state(self, cur_state, target_names=None):
         """
             更新状态，决定是否触发
+
+            参数：
+                cur_state:          <dict> 状态
+                target_names:       <list of str> 需要更新的目标
+                                        默认为 None,此时将更新所有目标
         """
         assert isinstance(cur_state, (dict,))
+        target_names = [""] if target_names is None else target_names
+        assert isinstance(target_names, (list,))
 
         new_state = dict()
         for key, value in cur_state.items():
@@ -62,8 +89,35 @@ class Trigger:
                 new_state[key] = value
 
         if len(new_state) > 0:
-            for func in self.func_ls:
-                func(new_state)
+            # get funcs to update
+            func_s = dict()
+            for target_name in target_names:
+                var = self.database.get(name=target_name, b_pop=False, default=None)
+                if isinstance(var, (list, dict,)):
+                    func_s.update({target_name + k: v for k, v in fndl.get_nodes(var=var, level=-1, b_strict=True)})
+                else:
+                    func_s[target_name] = var
+            # update
+            for func in func_s.values():
+                if func is not None:
+                    func(new_state)
             self.last_state.update(new_state)
 
         return new_state
+
+    # ---------------------- 用于保存和加载触发器的状态 ---------------------- #
+
+    def load_state_dict(self, state_dict):
+        """
+            加载触发器状态
+        """
+        self.last_state = state_dict["last_state"]
+
+    def state_dict(self):
+        """
+            获取触发器状态
+        """
+        return {"last_state": copy.deepcopy(self.last_state)}
+
+    def clear_state_dict(self):
+        self.last_state.clear()

kevin_toolbox/patches/for_test/check_consistency.py

@@ -49,9 +49,11 @@ def check_consistency(*args, tolerance=1e-7, require_same_shape=True):
             for i, j in zip(args[0].reshape(-1), v.reshape(-1)):
                 temp = i == j
                 if isinstance(temp, (bool,)):
-                    assert temp
+                    assert temp, \
+                        f"{args[0]}, {v}, diff: {temp}"
                 else:
-                    assert temp.all()
+                    assert temp.all(), \
+                        f"{args[0]}, {v}, diff: {temp}"
         else:
             raise ValueError
 

kevin_toolbox_dev-1.1.3.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.1.3
+Summary: 一个常用的工具代码包集合
+Home-page: https://github.com/cantbeblank96/kevin_toolbox
+Download-URL: https://github.com/username/your-package/archive/refs/tags/v1.0.0.tar.gz
+Author: kevin hsu
+Author-email: xukaiming1996@163.com
+License: MIT
+Keywords: mathematics,pytorch,numpy,machine-learning,algorithm
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: torch (>=1.2.0)
+Requires-Dist: numpy (>=1.19.0)
+Provides-Extra: plot
+Requires-Dist: matplotlib (>=3.0) ; extra == 'plot'
+Provides-Extra: rest
+Requires-Dist: pytest (>=6.2.5) ; extra == 'rest'
+Requires-Dist: line-profiler (>=3.5) ; extra == 'rest'
+
+# kevin_toolbox
+
+一个通用的工具代码包集合
+
+
+
+环境要求
+
+```shell
+numpy>=1.19
+pytorch>=1.2
+```
+
+安装方法：
+
+```shell
+pip install kevin-toolbox  --no-dependencies
+```
+
+
+
+[项目地址 Repo](https://github.com/cantbeblank96/kevin_toolbox)
+
+[使用指南 User_Guide](./notes/User_Guide.md)
+
+[免责声明 Disclaimer](./notes/Disclaimer.md)
+
+[版本更新记录](./notes/Release_Record.md)：
+
+- v 1.1.3（2023-06-30）
+  - computer_science.algorithm.for_nested_dict_list
+    - 在 traverse() 中新增了traversal_mode 参数用于控制遍历的顺序，目前支持三种模式： "dfs_pre_order" 深度优先-先序遍历、"dfs_post_order" 深度优先-后序遍历、以及 "bfs" 宽度优先。
+      - 在单元测试中新增了对 traverse() 中 traversal_mode 参数的测试项目。
+    - value_parser
+      - 修改 eval_references() 中 converter_for_ref 参数的行为，从原来只是作为计算结果前对算式中引用节点值的预处理，变成直接改变被引用节点的值。亦即原来不会修改原被引用节点的值，现在变为会修改原节点的值了。
+  - computer_science.algorithm.scheduler
+    - 改进 Strategy_Manager
+      - 使用 `<eval>` 来标记需要使用 eval() 函数读取的字符串。相对于旧版通过 `<eval>` 来标记需要被读取为函数的字符串，使用 `<eval>` 不仅可以读取函数，也可以读取更多的数据结构。
+      - 在通过 add() 添加策略时即对 strategy 中被 `<eval>` 标记的键值进行解释，而非等到后续每次 cal() 时再进行解释，提高了效率。
+      - 修改了对应的单元测试。

{kevin_toolbox_dev-1.1.1.dist-info → kevin_toolbox_dev-1.1.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-kevin_toolbox/__init__.py,sha256=DFpREPfEjN9P8LPXS5zxzqv3ubGbXwB1AQYyOAF5Hdc,410
+kevin_toolbox/__init__.py,sha256=vAS6Ot-u8d3-594niDe3hf21gjSztypz4qspgIG4jNU,410
 kevin_toolbox/computer_science/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kevin_toolbox/computer_science/algorithm/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 kevin_toolbox/computer_science/algorithm/combinatorial_optimization/__init__.py,sha256=fBMX0_WiV8kfHLWZNfVe2uL67gsN_oHfpbuHaHUOiys,142
@@ -10,20 +10,20 @@ kevin_toolbox/computer_science/algorithm/combinatorial_optimization/test/test_ze
 kevin_toolbox/computer_science/algorithm/for_dict/__init__.py,sha256=YFxhbWIsOMGf7ay3fh0sosvXzpuqQQC1bkXK75LAqO4,37
 kevin_toolbox/computer_science/algorithm/for_dict/deep_update.py,sha256=_1GL8-zY1t48rp3N_SiirjYPzLwQSN_cpmzLKymOnQI,666
 kevin_toolbox/computer_science/algorithm/for_nested_dict_list/__init__.py,sha256=tOEHNkIRhCMTjAaNNjn_Wa6FXNvQTyNC2erJN0rpLkw,273
-kevin_toolbox/computer_science/algorithm/for_nested_dict_list/copy_.py,sha256=NQp6sq2yPJQ--PfV9vgtIMkgjRNmGk1gtpKAn-dRYsc,887
+kevin_toolbox/computer_science/algorithm/for_nested_dict_list/copy_.py,sha256=vOHiHg8UHnETy5e3hODzSnGHGMlxcFml4Q1qbX88aEI,939
 kevin_toolbox/computer_science/algorithm/for_nested_dict_list/count_leaf_node_nums.py,sha256=CY9fXmdkwWqHwP62LyxCp7uqt5OMNcSm1zD4s4Ol_x0,645
 kevin_toolbox/computer_science/algorithm/for_nested_dict_list/get_hash.py,sha256=Ygadnn5dnvIeE-9t39p2EwNKNRLzomL37ZsRD5daXxo,1286
 kevin_toolbox/computer_science/algorithm/for_nested_dict_list/get_nodes.py,sha256=tpRAE3p_ER9Kj4GwP7ub_ZYm_qITRxAzom2t2EHUyms,3543
-kevin_toolbox/computer_science/algorithm/for_nested_dict_list/get_value_by_name.py,sha256=Jy-HcRdQSdcCvIVpSXJ0QCMX7HGMNLllPt8aRk43zCM,1303
-kevin_toolbox/computer_science/algorithm/for_nested_dict_list/set_value_by_name.py,sha256=Bqqewcli6MdLkAtRHxh8B8IYr1vkMoL3K5-_FVb22p0,2842
-kevin_toolbox/computer_science/algorithm/for_nested_dict_list/traverse.py,sha256=mBWHsEKYRGqEeQ1h6fD6FbwW_UO67GOARS33wB_GhuI,3951
+kevin_toolbox/computer_science/algorithm/for_nested_dict_list/get_value_by_name.py,sha256=MlpfZrr95VrZgKpjV_CtJSc7LG1l79_5JUJ6_phwVxo,2122
+kevin_toolbox/computer_science/algorithm/for_nested_dict_list/set_value_by_name.py,sha256=aFZL5P9C3kbJEfNBNgr760B7mYWSunirjTU-EpglGbk,2875
+kevin_toolbox/computer_science/algorithm/for_nested_dict_list/traverse.py,sha256=3g--9_icGWN2CuXu1qXyzsCxovf0UymutD3_C2DJkP4,6889
 kevin_toolbox/computer_science/algorithm/for_nested_dict_list/name_handler/__init__.py,sha256=P_pWq78oN6NdvWg2h6AduW_sUqbeaaVyoWWbW9kbgmU,107
 kevin_toolbox/computer_science/algorithm/for_nested_dict_list/name_handler/build_name.py,sha256=63xfhk1-lUButEdn76I32Sx-osvKF8A8KJBNylA2QBI,1051
 kevin_toolbox/computer_science/algorithm/for_nested_dict_list/name_handler/escape_node.py,sha256=niT9MxmsyrSZYhKXlWzdoKXVYhWRCR-kmQBkZopznpA,1163
 kevin_toolbox/computer_science/algorithm/for_nested_dict_list/name_handler/parse_name.py,sha256=bk1vdBIX07Nu52hd805GqIWj51vnaJiq-owBAJGP-O4,2350
 kevin_toolbox/computer_science/algorithm/for_nested_dict_list/value_parser/__init__.py,sha256=9Z-zlaCakJsb8oB_ZpzUGxdH743gmoXrwJJCTP1viLY,169
 kevin_toolbox/computer_science/algorithm/for_nested_dict_list/value_parser/cal_relation_between_references.py,sha256=csxrOB_QZIOlTJo9-buBOkEwyE2mGRbq2_dzvXwkNjs,3181
-kevin_toolbox/computer_science/algorithm/for_nested_dict_list/value_parser/eval_references.py,sha256=XWApZnrMaS8HEZ4UOb1J41BW9DkIwJgqhqoDK8BFC0w,1737
+kevin_toolbox/computer_science/algorithm/for_nested_dict_list/value_parser/eval_references.py,sha256=Dx4tAu51wRqTTQlYOw2NrGszxPnMukbIDbXY74P-CIc,2372
 kevin_toolbox/computer_science/algorithm/for_nested_dict_list/value_parser/parse_references.py,sha256=SYmJSC8IO-6VlCT1BlM9924kEuRbO4rGEN8hpPjlDhc,2155
 kevin_toolbox/computer_science/algorithm/for_seq/__init__.py,sha256=qXNVulpOBOWlD2yJ9L4D5bfrNFmnBd29ibtUbvaJHYk,76
 kevin_toolbox/computer_science/algorithm/for_seq/flatten_list.py,sha256=XnDq-_nQln55vwpAnBslyOKI_KYq11C7PmfLChhSe0k,1046
@@ -33,10 +33,10 @@ kevin_toolbox/computer_science/algorithm/locks/mutex_lock.py,sha256=81cCw3oTXCZx
 kevin_toolbox/computer_science/algorithm/pareto_front/__init__.py,sha256=LbeaSzG0hkx8NHAlzvEalrGi2WufaXguVfeBRzaw-MA,57
 kevin_toolbox/computer_science/algorithm/pareto_front/get_pareto_points_idx.py,sha256=a-8Js-dpkuVu9MsImW9hwHp9OTC278xo9oJP96oX0Io,2712
 kevin_toolbox/computer_science/algorithm/registration/__init__.py,sha256=teEd9HkrB6baLpwNwae5c4wn0QRwV3KtBv-2V9-Z7cc,49
-kevin_toolbox/computer_science/algorithm/registration/registry.py,sha256=v0XcH8Rde31OvrZ9C3rBfL0FY8GvHUc-u1OJ1RexHN0,13982
+kevin_toolbox/computer_science/algorithm/registration/registry.py,sha256=Luz48VmqS8BR8sjwQrfHnI0biAYv06rG8ZyXTskPvfA,13567
 kevin_toolbox/computer_science/algorithm/scheduler/__init__.py,sha256=ENzZsNaMu6ISilTxeE3_EP_L0dNi8SI7IYdTdxic2nw,76
-kevin_toolbox/computer_science/algorithm/scheduler/strategy_manager.py,sha256=yVOLk_k-V_RN7GMTx2-fL4eXbHa-DQDnIbmbpvGamyc,11495
-kevin_toolbox/computer_science/algorithm/scheduler/trigger.py,sha256=dCKX2f8aPtzE88-upbcuyNRpe3nx8CK2T9CM1lW7_iU,2203
+kevin_toolbox/computer_science/algorithm/scheduler/strategy_manager.py,sha256=nzKLaKOmIAc6Hrm1O6KAm49yvJtIWMUY-gaswslkIb4,12265
+kevin_toolbox/computer_science/algorithm/scheduler/trigger.py,sha256=WDkM635xcB3ZoPzOCJUwLHju22Fuji7PA7xCx-ZQLOI,4508
 kevin_toolbox/computer_science/algorithm/search/__init__.py,sha256=zja7FXLTNd2dSVzzGp1TbBp4i3TDY8S9tcJ9pqc684A,41
 kevin_toolbox/computer_science/algorithm/search/binary_search.py,sha256=FcOdgxfuNews_AhPF_CoQDr2vBPqpUpifF7Fmgml1p4,1013
 kevin_toolbox/computer_science/algorithm/statistician/__init__.py,sha256=zW1zesXYNjh6cAZPz_gsXd2LEEPlvA7SNB0huCb9WCg,120
@@ -207,7 +207,7 @@ kevin_toolbox/patches/for_optuna/sample_from_feasible_domain.py,sha256=v_qrPPWE2
 kevin_toolbox/patches/for_os/__init__.py,sha256=mdbhe6Nvgbkt8v960ATmnKtF-4ds94yIU0-k3k14dHc,27
 kevin_toolbox/patches/for_os/remove.py,sha256=ji71D3BQA8g-xZr7IMRD9ANXfdsszS9QXDopAfVHfnw,658
 kevin_toolbox/patches/for_test/__init__.py,sha256=sFr2VZD1zk8Vtjq2_F8uE4xNovJF6yDY8j1YND5XAw0,49
-kevin_toolbox/patches/for_test/check_consistency.py,sha256=-A2VYECmLzGHkAWavPNbpZBT9Nsdm4nlNOkmX5CBwLo,3066
+kevin_toolbox/patches/for_test/check_consistency.py,sha256=gSss0OUwpp4WqD08iUiuIjyNVGTGw77jSt-RqDMgQ_A,3184
 kevin_toolbox/patches/for_torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kevin_toolbox/patches/for_torch/compatible/__init__.py,sha256=7l4FPTILBR8EmStJNHIsbwfFkZpe4xkJZtrlyC8riL8,75
 kevin_toolbox/patches/for_torch/compatible/concat.py,sha256=vFJn9B437gxDOa5Ze_gXxZewiClqoiIkWeAktDEcJK4,393
@@ -223,7 +223,7 @@ kevin_toolbox/patches/for_torch/math/get_y_at_x.py,sha256=bfoVcasZ_tMdhR_1Me0Jli
 kevin_toolbox/patches/for_torch/math/my_around.py,sha256=ptpU3ids50gwf663EpHbw7raj9tNrDGBFZ5t_uMNH14,1378
 kevin_toolbox/patches/for_torch/nn/__init__.py,sha256=aJs3RMqRzQmd8KKDmQW9FxwCqS5yfPqEdg-m0PwlQro,39
 kevin_toolbox/patches/for_torch/nn/lambda_layer.py,sha256=KUuLiX_Dr4bvRmpAaCW5QTDWDcnMPRnw0jg4NNXTFhM,223
-kevin_toolbox_dev-1.1.1.dist-info/METADATA,sha256=pwrwgslJERvXHu0fBaI_YoTbzaOG5wCTaMCwaPKiQEQ,5453
-kevin_toolbox_dev-1.1.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-kevin_toolbox_dev-1.1.1.dist-info/top_level.txt,sha256=S5TeRGF-PwlhsaUEPTI-f2vWrpLmh3axpyI6v-Fi75o,14
-kevin_toolbox_dev-1.1.1.dist-info/RECORD,,
+kevin_toolbox_dev-1.1.3.dist-info/METADATA,sha256=-D6TRFBMXRFA2QT9wyr4Zz4sF5TrKmGrKs8gIPHEI24,2494
+kevin_toolbox_dev-1.1.3.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+kevin_toolbox_dev-1.1.3.dist-info/top_level.txt,sha256=S5TeRGF-PwlhsaUEPTI-f2vWrpLmh3axpyI6v-Fi75o,14
+kevin_toolbox_dev-1.1.3.dist-info/RECORD,,

kevin_toolbox_dev-1.1.1.dist-info/METADATA

@@ -1,127 +0,0 @@
-Metadata-Version: 2.1
-Name: kevin-toolbox-dev
-Version: 1.1.1
-Summary: 一个常用的工具代码包集合
-Home-page: https://github.com/cantbeblank96/kevin_toolbox
-Download-URL: https://github.com/username/your-package/archive/refs/tags/v1.0.0.tar.gz
-Author: kevin hsu
-Author-email: xukaiming1996@163.com
-License: MIT
-Keywords: mathematics,pytorch,numpy,machine-learning,algorithm
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Requires-Dist: torch (>=1.2.0)
-Requires-Dist: numpy (>=1.19.0)
-Provides-Extra: plot
-Requires-Dist: matplotlib (>=3.0) ; extra == 'plot'
-Provides-Extra: rest
-Requires-Dist: pytest (>=6.2.5) ; extra == 'rest'
-Requires-Dist: line-profiler (>=3.5) ; extra == 'rest'
-
-# kevin_toolbox
-
-一个通用的工具代码包集合
-
-
-
-环境要求
-
-```shell
-numpy>=1.19
-pytorch>=1.2
-```
-
-安装方法：
-
-```shell
-pip install kevin-toolbox  --no-dependencies
-```
-
-
-
-[项目地址 Repo](https://github.com/cantbeblank96/kevin_toolbox)
-
-[使用指南 User_Guide](./notes/User_Guide.md)
-
-[免责声明 Disclaimer](./notes/Disclaimer.md)
-
-[版本更新记录](./notes/Release_Record.md)：
-
-- v 1.1.0（2023-06-21）【bug fix】
-  - computer_science.algorithm.for_dict
-    - fix bug in deep_update()，修复了无法更新stem中值为None的部分的问题。
-    - 添加了单元测试
-
-  - computer_science.algorithm.for_nested_dict_list
-
-    - 新增模块 name_handler 用于处理名字的解释、构造等
-
-      - parse_name() 解释名字 name 得到：root_node、取值方式 method_ls 、取值时使用的键 node_ls
-      - build_name()  根据root_node、取值方式 method_ls 、取值时使用的键 node_ls，来构造名字 name
-      - escape_node() 对键进行转义/反转义
-      - 添加了单元测试
-      - 添加了说明文档
-      - 支持了转义字符。对于含有特殊字符 :|@ 的 node，可以对 node 中的这些特殊字符使用 \ 进行转义，避免将这些字符解释为取值方式。
-
-    - 结合 name_handler 修改了 get_value_by_name()、get_nodes()、traverse()、set_value_by_name()
-
-    - 改进了 set_value_by_name()，支持强制创建列表
-
-    - 新增模块 value_parser 用于处理带有引用的值
-
-      - 什么是引用？
-
-        - 对于值，若为字符串类型，且其中含有 `"...<flag>{ref_name}..."` 的形式，则表示解释该值时需要将 `<flag>{ref_name}` 这部分替换为 var 中 ref_name 对应的值
-
-      - parse_references() 解释 var 中包含引用的值
-
-        - ```
-          比如对于：
-              name=":z", value="<v>{:x}+<v>{:y}"
-          的节点，将会返回：
-              {":z": {"expression":"p_0+p_1" , "paras": {"p_0":":x","p_1":":y"}}, ...}
-          利用 "expression" 和 "paras" 中的内容，将可以很方便得使用 eval() 和 get_value_by_name() 完成对节点值的计算。
-          但是由于节点之间可能存在相互引用，因此一般需要通过 cal_relation_between_references() 来确定计算顺序。
-          ```
-
-      - cal_relation_between_references() 计算具有引用的节点之间的关系
-
-        - ```
-          函数返回值：
-              node_s, b_is_DAG, order
-          
-              node_s:             <dict> 在输入的 node_s 的基础上为每个节点补充 upstream_node 和 downstream_node 字段
-                                      其中：
-                                          upstream_node 中保存该节点所依赖的上游节点，意味着要等这些上游节点计算完毕后才能计算该节点
-                                          downstream_node 中保存对该节点有依赖的下游节点。
-              b_is_DAG:           <boolean> 节点关系是否满足有向无环图 DAG
-              order:              <list of name> 节点在 DAG 中的顺序
-          ```
-
-      - eval_references() 将 var 中的具有引用的值替换为计算结果
-
-  - data_flow.file.kevin_notation
-
-    - 修改 write_contents() 支持通过 b_single_line 参数来明确指定是使用单行or多行模式进行写入
-    - 修改 `__setattr__()` 支持通过前缀 "row_ls" or "column_dict" 来指定写入内容的组织形式，支持通过添加后缀 "single_line" or "multi_line" 来明确指定按照单行or多行模式进行写入
-      - 例如 self.row_ls_single_line = value 等效于 self.write_contents(row_ls=value, b_single_line=True)
-
-  - computer_science.algorithm.registration
-
-    - 改进 Registry 类
-      - 在 add() 中也增加了b_execute_now 来控制延时导入
-      - 在 collect_from_paths() 中新增了 path_ls_to_exclude 参数用于指定需要排除的目录
-      - 改进了 collect_from_paths() 中路径的搜索方式，改为从深到浅导入，可以避免继承引起的 TypeError: super(type, obj) 类型错误
-
-  - computer_science.algorithm.scheduler
-
-    - 修改 Trigger 类中的 bind() 方法，支持直接读取实例的 update_by_state() 函数进行绑定。同时也新增了 bind_func() 和 bind_obj() 用于在明确待绑定对象类型时使用。
-
-- v 1.1.1（2023-06-21）
-
-  - computer_science.algorithm.for_nested_dict_list.value_parser
-    - 在 eval_references() 中新增了参数 converter_for_ref 和 converter_for_res 用于指定对 引用值 和 计算结果 施加何种处理
-