kevin-toolbox-dev 1.1.2__tar.gz → 1.1.3__tar.gz

kevin-toolbox-dev-1.1.3/PKG-INFO

@@ -0,0 +1,58 @@
+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
+Provides-Extra: plot
+Provides-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.3/README.md

@@ -0,0 +1,40 @@
+# 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.2 → kevin-toolbox-dev-1.1.3}/kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.1.2"
+__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 1703415924 --verbose 0'
+    f'--expiration_timestamp 1703667553 --verbose 0'
 )

{kevin-toolbox-dev-1.1.2 → kevin-toolbox-dev-1.1.3}/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-dev-1.1.3/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/traverse.py

@@ -0,0 +1,148 @@
+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, traversal_mode="dfs_pre_order", b_traverse_matched_element=False):
+    """
+        遍历 var 找到符合 match_cond 的元素，将其按照 action_mode 指定的操作进行处理
+
+        参数：
+            var:                待处理数据
+                                    当 var 不是 dict 或者 list 时，将直接返回 var 而不做处理
+            match_cond:         <func> 元素的匹配条件
+                                    函数类型为 def(parent_type, idx, value): ...
+                                    其中：
+                                        parent_type     该元素源自哪种结构体，有两个可能传入的值： list，dict
+                                        idx             该元素在结构体中的位置
+                                                            当 b_use_name_as_idx=False 时，
+                                                                对于列表是 index，对于字典是 key
+                                                            当为 True 时，传入的是元素在整体结构中的 name 位置，name的格式和含义参考
+                                                                name_handler.parse_name() 中的介绍
+                                        value           元素的值
+            action_mode:        <str> 如何对匹配上的元素进行处理
+                                    目前支持：
+                                        "remove"        将该元素移除
+                                        "replace"       将该元素替换为 converter() 处理后的结果
+                                        "skip":         不进行任何操作
+            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 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]
+
+    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)
+
+            # 匹配&处理
+            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)):
+        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))
+            # 递归遍历
+            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-dev-1.1.2 → kevin-toolbox-dev-1.1.3}/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-dev-1.1.2 → kevin-toolbox-dev-1.1.3}/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-dev-1.1.3/kevin_toolbox_dev.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+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
+Provides-Extra: plot
+Provides-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.2/PKG-INFO

@@ -1,70 +0,0 @@
-Metadata-Version: 2.1
-Name: kevin-toolbox-dev
-Version: 1.1.2
-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
-Provides-Extra: plot
-Provides-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.2（2023-06-27）【bug fix】
-
-  - computer_science.algorithm.for_nested_dict_list
-    - 改进 get_value_by_name()
-      - 新增了参数 b_pop 用于支持取值的同时将该值从 var 中移除
-      - 新增了参数 default 用于设置取值失败时是报错还是返回默认值
-  - computer_science.algorithm.registration
-    - Registry
-      - 【bug fix】修复了问题：当已有实例的 uid 为正整数 n，同时 cls.__counter 为 n 时，不指定 uid 再创建实例将错误地返回 uid=n 的已有实例而不是新建一个。
-      - 将 self.pop() 函数的功能合并到 self.get(... ,b_pop=...) 中
-  - computer_science.algorithm.scheduler
-    - 改进 Trigger
-      - 使用 Registry 来管理触发目标
-      - 新增 self.unbind() 函数来解除绑定
-      - 在 update_by_state() 中新增了 target_names 参数来决定调用哪些目标
-      - 新增 Trigger 的状态管理相关函数
-        - self.clear_state_dict(): 清除 Trigger 中保存的状态
-        - self.load_state_dict(): 加载
-        - self.state_dict(): 获取
-        - load_state_dict 和 state_dict 的接口名称是为了和 pytorch 中模型、优化器的状态加载、获取保持一致。
-
-  
-

kevin-toolbox-dev-1.1.2/README.md

@@ -1,52 +0,0 @@
-# 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.2（2023-06-27）【bug fix】
-
-  - computer_science.algorithm.for_nested_dict_list
-    - 改进 get_value_by_name()
-      - 新增了参数 b_pop 用于支持取值的同时将该值从 var 中移除
-      - 新增了参数 default 用于设置取值失败时是报错还是返回默认值
-  - computer_science.algorithm.registration
-    - Registry
-      - 【bug fix】修复了问题：当已有实例的 uid 为正整数 n，同时 cls.__counter 为 n 时，不指定 uid 再创建实例将错误地返回 uid=n 的已有实例而不是新建一个。
-      - 将 self.pop() 函数的功能合并到 self.get(... ,b_pop=...) 中
-  - computer_science.algorithm.scheduler
-    - 改进 Trigger
-      - 使用 Registry 来管理触发目标
-      - 新增 self.unbind() 函数来解除绑定
-      - 在 update_by_state() 中新增了 target_names 参数来决定调用哪些目标
-      - 新增 Trigger 的状态管理相关函数
-        - self.clear_state_dict(): 清除 Trigger 中保存的状态
-        - self.load_state_dict(): 加载
-        - self.state_dict(): 获取
-        - load_state_dict 和 state_dict 的接口名称是为了和 pytorch 中模型、优化器的状态加载、获取保持一致。
-
-  
-

kevin-toolbox-dev-1.1.2/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/traverse.py

@@ -1,69 +0,0 @@
-from kevin_toolbox.computer_science.algorithm.for_nested_dict_list.name_handler import escape_node
-
-
-def traverse(var, match_cond, action_mode="remove", converter=None,
-             b_use_name_as_idx=False, b_traverse_matched_element=False):
-    """
-        遍历 var 找到符合 match_cond 的元素，将其按照 action_mode 指定的操作进行处理
-
-        参数：
-            var:                待处理数据
-                                    当 var 不是 dict 或者 list 时，将直接返回 var 而不做处理
-            match_cond:         <func> 元素的匹配条件
-                                    函数类型为 def(parent_type, idx, value): ...
-                                    其中：
-                                        parent_type     该元素源自哪种结构体，有两个可能传入的值： list，dict
-                                        idx             该元素在结构体中的位置
-                                                            当 b_use_name_as_idx=False 时，
-                                                                对于列表是 index，对于字典是 key
-                                                            当为 True 时，传入的是元素在整体结构中的 name 位置，name的格式和含义参考
-                                                                name_handler.parse_name() 中的介绍
-                                        value           元素的值
-            action_mode:        <str> 如何对匹配上的元素进行处理
-                                    目前支持：
-                                        "remove"        将该元素移除
-                                        "replace"       将该元素替换为 converter() 处理后的结果
-                                        "skip":         不进行任何操作
-            converter:          <func> 参见 action_mode 中的 "replace" 模式
-                                    函数类型为 def(idx, value): ...
-                                    其中 idx 和 value 的含义参见参数 match_cond 介绍
-            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 callable(converter)
-
-    return recursive_(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element, "")
-
-
-def recursive_(var, match_cond, action_mode, converter, b_use_name_as_idx, 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
-            # 递归遍历
-            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)
-    else:
-        pass
-    return var