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

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/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/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/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.2.dist-info → kevin_toolbox_dev-1.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kevin-toolbox-dev
-Version: 1.1.2
+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
@@ -50,26 +50,14 @@ pip install kevin-toolbox  --no-dependencies
 
 [版本更新记录](./notes/Release_Record.md)：
 
-- v 1.1.2（2023-06-27）【bug fix】
-
+- v 1.1.3（2023-06-30）
   - 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=...) 中
+    - 在 traverse() 中新增了traversal_mode 参数用于控制遍历的顺序，目前支持三种模式： "dfs_pre_order" 深度优先-先序遍历、"dfs_post_order" 深度优先-后序遍历、以及 "bfs" 宽度优先。
+      - 在单元测试中新增了对 traverse() 中 traversal_mode 参数的测试项目。
+    - value_parser
+      - 修改 eval_references() 中 converter_for_ref 参数的行为，从原来只是作为计算结果前对算式中引用节点值的预处理，变成直接改变被引用节点的值。亦即原来不会修改原被引用节点的值，现在变为会修改原节点的值了。
   - 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 中模型、优化器的状态加载、获取保持一致。
-
-  
-
+    - 改进 Strategy_Manager
+      - 使用 `<eval>` 来标记需要使用 eval() 函数读取的字符串。相对于旧版通过 `<eval>` 来标记需要被读取为函数的字符串，使用 `<eval>` 不仅可以读取函数，也可以读取更多的数据结构。
+      - 在通过 add() 添加策略时即对 strategy 中被 `<eval>` 标记的键值进行解释，而非等到后续每次 cal() 时再进行解释，提高了效率。
+      - 修改了对应的单元测试。

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

@@ -1,4 +1,4 @@
-kevin_toolbox/__init__.py,sha256=Uxqn69hN-4zRQm_bQT-HIU11b0-JLq2tRoC4sv1ghKg,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=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=mBWHsEKYRGqEeQ1h6fD6FbwW_UO67GOARS33wB_GhuI,3951
+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
@@ -35,7 +35,7 @@ kevin_toolbox/computer_science/algorithm/pareto_front/get_pareto_points_idx.py,s
 kevin_toolbox/computer_science/algorithm/registration/__init__.py,sha256=teEd9HkrB6baLpwNwae5c4wn0QRwV3KtBv-2V9-Z7cc,49
 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/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
@@ -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.2.dist-info/METADATA,sha256=qDJuuM-xBgSWgcwL_plh-ZqcYfjDij7F8E3qdoNk_-c,2489
-kevin_toolbox_dev-1.1.2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-kevin_toolbox_dev-1.1.2.dist-info/top_level.txt,sha256=S5TeRGF-PwlhsaUEPTI-f2vWrpLmh3axpyI6v-Fi75o,14
-kevin_toolbox_dev-1.1.2.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,,