kevin-toolbox-dev 1.4.8__tar.gz → 1.4.9__tar.gz

kevin-toolbox-dev-1.4.9/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.4.9
+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
+Platform: UNKNOWN
+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.4.9 （2025-03-27）【new feature】【bug fix】
+
+  - patches.for_numpy.linalg
+    - 【bug fix】fix bug in softmax()，修改 33 行，从减去全局最大值改为减去各个分组内部的最大值，避免全局最大值过大导致某些分组全体数值过小导致计算溢出。
+  - patches.for_matplotlib.common_charts.utils
+    - modify save_plot()，在最后增加 plt.close() 用于及时销毁已使用完的画布，避免不必要的内存占用。
+  - nested_dict_list
+    - 【new feature】modify traverse()，增加以下参数以更加精确地控制遍历时的行为：
+      - b_skip_repeated_non_leaf_node:  是否跳过重复的非叶节点。
+        - 何为重复？在内存中的id相同。
+        - 默认为 None，此时将根据 action_mode 的来决定：
+          - 对于会对节点进行修改的模式，比如 "remove" 和 "replace"，将设为 True，以避免预期外的重复转换和替换。
+          - 对于不会修改节点内容的模式，比如 "skip"，将设为 False。
+      - cond_for_repeated_leaf_to_skip：函数列表。在叶节点位置上，遇到满足其中某个条件的重复的元素时需要跳过。
+    - 同步修改内部使用了 traverse() 的 get_nodes() 和 copy_() 等函数。
+    - 新增了对应的测试用例。
+  - data_flow.file.json_
+    - 【bug fix】fix bug in write()。
+      - bug 归因：在 json_.write() 中通过使用 ndl.traverse() 来找出待转换的元素并进行转换，但是在 v1.4.8 前，该函数默认不会跳过重复（在内存中的id相同）出现的内容。由于该内容的不同引用实际上指向的是同一个，因此对这些引用的分别多次操作实际上就是对该内容进行了多次操作。
+      - bug 解决：在后续 v1.4.9 中为 ndl.traverse() 新增了 b_skip_repeated_non_leaf_node 用于控制是否需要跳过重复的引用。我们只需要在使用该函数时，令参数 b_skip_repeated_non_leaf_node=True即可。
+
+

kevin-toolbox-dev-1.4.9/README.md

@@ -0,0 +1,49 @@
+# 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.4.9 （2025-03-27）【new feature】【bug fix】
+
+  - patches.for_numpy.linalg
+    - 【bug fix】fix bug in softmax()，修改 33 行，从减去全局最大值改为减去各个分组内部的最大值，避免全局最大值过大导致某些分组全体数值过小导致计算溢出。
+  - patches.for_matplotlib.common_charts.utils
+    - modify save_plot()，在最后增加 plt.close() 用于及时销毁已使用完的画布，避免不必要的内存占用。
+  - nested_dict_list
+    - 【new feature】modify traverse()，增加以下参数以更加精确地控制遍历时的行为：
+      - b_skip_repeated_non_leaf_node:  是否跳过重复的非叶节点。
+        - 何为重复？在内存中的id相同。
+        - 默认为 None，此时将根据 action_mode 的来决定：
+          - 对于会对节点进行修改的模式，比如 "remove" 和 "replace"，将设为 True，以避免预期外的重复转换和替换。
+          - 对于不会修改节点内容的模式，比如 "skip"，将设为 False。
+      - cond_for_repeated_leaf_to_skip：函数列表。在叶节点位置上，遇到满足其中某个条件的重复的元素时需要跳过。
+    - 同步修改内部使用了 traverse() 的 get_nodes() 和 copy_() 等函数。
+    - 新增了对应的测试用例。
+  - data_flow.file.json_
+    - 【bug fix】fix bug in write()。
+      - bug 归因：在 json_.write() 中通过使用 ndl.traverse() 来找出待转换的元素并进行转换，但是在 v1.4.8 前，该函数默认不会跳过重复（在内存中的id相同）出现的内容。由于该内容的不同引用实际上指向的是同一个，因此对这些引用的分别多次操作实际上就是对该内容进行了多次操作。
+      - bug 解决：在后续 v1.4.9 中为 ndl.traverse() 新增了 b_skip_repeated_non_leaf_node 用于控制是否需要跳过重复的引用。我们只需要在使用该函数时，令参数 b_skip_repeated_non_leaf_node=True即可。

{kevin-toolbox-dev-1.4.8 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.4.8"
+__version__ = "1.4.9"
 
 
 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 1756803931 --verbose 0'
+    f'--expiration_timestamp 1758638079 --verbose 0'
 )

{kevin-toolbox-dev-1.4.8 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/data_flow/file/json_/write_json.py

@@ -56,7 +56,8 @@ def write_json(content, file_path, converters=None, b_use_suggested_converter=Fa
         content = traverse(var=[copy.deepcopy(content)],
                            match_cond=lambda _, __, ___: True, action_mode="replace",
                            converter=lambda _, x: converter(x),
-                           b_traverse_matched_element=True)[0]
+                           b_traverse_matched_element=True,
+                           b_skip_repeated_non_leaf_node=True)[0]
 
     content = json.dumps(content, **output_format)
 

{kevin-toolbox-dev-1.4.8 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/env_info/check_version_and_update.py

@@ -16,7 +16,6 @@ def check_version_and_update(package_name, cur_version=None, available_versions=
         ex = subprocess.Popen(f'pip list | grep "{package_name} "', shell=True, stdout=subprocess.PIPE)
         out, _ = ex.communicate()
         out = out.decode().strip()
-        # breakpoint()
         cur_version = out.split(package_name)[-1].strip()
 
     # try to read available versions

{kevin-toolbox-dev-1.4.8 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/nested_dict_list/copy_.py

@@ -123,7 +123,8 @@ def _copy_structure(var, b_keep_internal_references):
 
     return traverse(var=[var], match_cond=lambda _, __, value: isinstance(value, (list, dict,)),
                     action_mode="replace", converter=converter,
-                    traversal_mode="dfs_pre_order", b_traverse_matched_element=True)[0]
+                    traversal_mode="dfs_pre_order", b_traverse_matched_element=True,
+                    b_skip_repeated_non_leaf_node=True)[0]
 
 
 def _copy_nodes(var, b_keep_internal_references):
@@ -149,7 +150,8 @@ def _copy_nodes(var, b_keep_internal_references):
 
     return traverse(var=[var], match_cond=lambda _, __, value: not isinstance(value, (list, dict,)),
                     action_mode="replace", converter=converter,
-                    traversal_mode="dfs_pre_order", b_traverse_matched_element=True)[0]
+                    traversal_mode="dfs_pre_order", b_traverse_matched_element=True,
+                    b_skip_repeated_non_leaf_node=True)[0]
 
 
 if __name__ == '__main__':

{kevin-toolbox-dev-1.4.8 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/nested_dict_list/get_nodes.py

@@ -2,7 +2,7 @@ from kevin_toolbox.nested_dict_list import traverse, get_value
 from kevin_toolbox.nested_dict_list.name_handler import parse_name
 
 
-def get_nodes(var, level=-1, b_strict=True):
+def get_nodes(var, level=-1, b_strict=True, **kwargs):
     """
         获取嵌套字典列表 var 中所有叶节点
             以列表 [(name,value), ...] 形式返回，其中名字 name 的解释方式参考 name_handler.parse_name() 介绍
@@ -23,6 +23,8 @@ def get_nodes(var, level=-1, b_strict=True):
                                     默认为 True，不添加。
     """
     assert isinstance(level, (int,))
+    kwargs.setdefault("b_skip_repeated_non_leaf_node", False)
+
     if level == 0:
         return [("", var)]
 
@@ -38,7 +40,7 @@ def get_nodes(var, level=-1, b_strict=True):
             res_empty.add(idx + "@None")  # 添加哨兵，表示空节点，并不会被实际解释
         return False
 
-    traverse(var=var, match_cond=func, action_mode="skip", b_use_name_as_idx=True)
+    traverse(var=var, match_cond=func, action_mode="skip", b_use_name_as_idx=True, **kwargs)
 
     if level != -1:
         names = set()

{kevin-toolbox-dev-1.4.8 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/nested_dict_list/traverse.py

@@ -15,7 +15,8 @@ class Traversal_Mode(Enum):
 
 
 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):
+             b_use_name_as_idx=False, traversal_mode="dfs_pre_order", b_traverse_matched_element=False,
+             b_skip_repeated_non_leaf_node=None, cond_for_repeated_leaf_to_skip=None, **kwargs):
     """
         遍历 var 找到符合 match_cond 的元素，将其按照 action_mode 指定的操作进行处理
 
@@ -48,46 +49,86 @@ def traverse(var, match_cond, action_mode="remove", converter=None,
                                     默认为 "dfs_pre_order"
             b_use_name_as_idx:  <boolean> 对于 match_cond/converter 中的 idx 参数，是传入整体的 name 还是父节点的 index 或 key。
                                     默认为 False
-            b_traverse_matched_element  <boolean> 对于匹配上的元素，经过处理后，是否继续遍历该元素的内容
+            b_traverse_matched_element: <boolean> 对于匹配上的元素，经过处理后，是否继续遍历该元素的内容
                                     默认为 False
+            b_skip_repeated_non_leaf_node:  <boolean> 是否跳过重复的非叶节点。
+                                    何为重复？
+                                        在内存中的id相同。
+                                    默认为 None，此时将根据 action_mode 的来决定：
+                                        - 对于会对节点进行修改的模式，比如 "remove" 和 "replace"，将设为 True，以避免预期外的重复转换和替换。
+                                        - 对于不会修改节点内容的模式，比如 "skip"，将设为 False。
+            cond_for_repeated_leaf_to_skip: <list/tuple of callable> 在叶节点位置上，遇到满足其中某个条件的重复的元素时需要跳过。
+                                    要求函数接受 叶节点的值，并返回一个 boolean，表示是否匹配成功。
+                                    默认为 None
     """
     assert callable(match_cond)
     action_mode = Action_Mode(action_mode)
     if action_mode is Action_Mode.REPLACE:
         assert callable(converter)
     traversal_mode = Traversal_Mode(traversal_mode)
+    if b_skip_repeated_non_leaf_node is None:
+        if action_mode is Action_Mode.SKIP:
+            b_skip_repeated_non_leaf_node = False
+        else:  # action_mode in (Action_Mode.REMOVE, Action_Mode.REPLACE)
+            b_skip_repeated_non_leaf_node = True
+    cond_for_repeated_leaf_to_skip = [] if cond_for_repeated_leaf_to_skip is None else cond_for_repeated_leaf_to_skip
+
+    passed_node_ids = {"leaf": set(), "non_leaf": set()}
 
     if traversal_mode is Traversal_Mode.BFS:
-        return _bfs(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element)
+        return _bfs(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element,
+                    b_skip_repeated_non_leaf_node=b_skip_repeated_non_leaf_node,
+                    cond_for_repeated_leaf_to_skip=cond_for_repeated_leaf_to_skip,
+                    passed_node_ids=passed_node_ids)
     else:
         return _dfs(var, match_cond, action_mode, converter, b_use_name_as_idx, traversal_mode,
-                    b_traverse_matched_element, "")
+                    b_traverse_matched_element, pre_name="",
+                    b_skip_repeated_non_leaf_node=b_skip_repeated_non_leaf_node,
+                    cond_for_repeated_leaf_to_skip=cond_for_repeated_leaf_to_skip,
+                    passed_node_ids=passed_node_ids)
 
 
-def _bfs(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element):
+def _bfs(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element,
+         b_skip_repeated_non_leaf_node, cond_for_repeated_leaf_to_skip, passed_node_ids):
     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())
+        pre_name, it = temp.pop(0)
+        if isinstance(it, (list, dict)):
+            #
+            if b_skip_repeated_non_leaf_node:
+                if id(it) in passed_node_ids["non_leaf"]:
+                    continue
+                else:
+                    passed_node_ids["non_leaf"].add(id(it))
+            #
+            keys = list(range(len(it)) if isinstance(it, list) else it.keys())
             keys.reverse()  # 反过来便于 列表 弹出元素
-            idx_ls = _gen_idx(i, keys, b_use_name_as_idx, pre_name)
+            idx_ls = _gen_idx(it, 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):
+                b_matched, b_popped, b_skip = _deal(it, k, idx, match_cond, converter, action_mode,
+                                                    cond_for_repeated_leaf_to_skip, passed_node_ids)
+                if b_skip or b_popped or (b_matched and not b_traverse_matched_element):
                     continue
                 # 添加到队尾
-                temp.append((idx, i[k]))
+                temp.append((idx, it[k]))
 
     return var
 
 
 def _dfs(var, match_cond, action_mode, converter,
-         b_use_name_as_idx, traversal_mode, b_traverse_matched_element, pre_name):
+         b_use_name_as_idx, traversal_mode, b_traverse_matched_element, pre_name,
+         b_skip_repeated_non_leaf_node, cond_for_repeated_leaf_to_skip, passed_node_ids):
     if isinstance(var, (list, dict)):
+        #
+        if b_skip_repeated_non_leaf_node:
+            if id(var) in passed_node_ids["non_leaf"]:
+                return var
+            else:
+                passed_node_ids["non_leaf"].add(id(var))
+        #
         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)
@@ -98,29 +139,42 @@ def _dfs(var, match_cond, action_mode, converter,
             # 匹配&处理
             deal_res_ls = []
             for k, idx in zip(keys, idx_ls):
-                deal_res_ls.append(_deal(var, k, idx, match_cond, converter, action_mode))
+                deal_res_ls.append(_deal(var, k, idx, match_cond, converter, action_mode,
+                                         cond_for_repeated_leaf_to_skip, passed_node_ids))
             # 递归遍历
-            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):
+            for (b_matched, b_popped, b_skip), k, idx in zip(deal_res_ls, keys, idx_ls):
+                if b_skip or 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)
+                              b_traverse_matched_element, idx,
+                              b_skip_repeated_non_leaf_node, cond_for_repeated_leaf_to_skip, passed_node_ids)
         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)
+                              b_traverse_matched_element, idx,
+                              b_skip_repeated_non_leaf_node, cond_for_repeated_leaf_to_skip, passed_node_ids)
             # 匹配&处理
             for k, idx in zip(keys, idx_ls):
-                _deal(var, k, idx, match_cond, converter, action_mode)
+                _deal(var, k, idx, match_cond, converter, action_mode,
+                      cond_for_repeated_leaf_to_skip, passed_node_ids)
     else:
         pass
     return var
 
 
-def _deal(var, k, idx, match_cond, converter, action_mode):
+def _deal(var, k, idx, match_cond, converter, action_mode,
+          cond_for_repeated_leaf_to_skip, passed_node_ids):
     """处理节点"""
+    b_skip = False
+
+    if cond_for_repeated_leaf_to_skip and not isinstance(var[k], (dict, list,)) and any(
+            [i(var[k]) for i in cond_for_repeated_leaf_to_skip]):
+        if id(var[k]) in passed_node_ids["leaf"]:
+            return None, None, True
+        else:
+            passed_node_ids["leaf"].add(id(var[k]))
     # 匹配
     b_matched = match_cond(type(var), idx, var[k])
     b_popped = False
@@ -133,7 +187,7 @@ def _deal(var, k, idx, match_cond, converter, action_mode):
             var[k] = converter(idx, var[k])
         else:
             pass
-    return b_matched, b_popped
+    return b_matched, b_popped, b_skip
 
 
 def _gen_idx(var, keys, b_use_name_as_idx, pre_name):

{kevin-toolbox-dev-1.4.8 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/nested_dict_list/value_parser/replace_identical_with_reference.py

@@ -70,10 +70,7 @@ def _forward(var, flag, match_cond):
         # 任选其一进行保留，其余改为引用
         keep_name = unprocessed_name_set.pop()
         for name in unprocessed_name_set:
-            try:
-                var = set_value(var=var, name=name, value=f'<{flag}>{{{keep_name}}}', b_force=False)
-            except:
-                breakpoint()
+            var = set_value(var=var, name=name, value=f'<{flag}>{{{keep_name}}}', b_force=False)
         processed_name_set.update(unprocessed_name_set)
 
     # 将叶节点中，未被处理过，且是 str，且以 flag 开头的字符串，添加多一个 flag，以示区分

{kevin-toolbox-dev-1.4.8 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/patches/for_matplotlib/color/convert_format.py

@@ -6,8 +6,6 @@ def hex_to_rgba(hex_color):
     assert len(hex_color) in (6, 8), \
         f'hex_color should be 6 or 8 characters long (not including #). but got {len(hex_color)}'
     res = list(int(hex_color[i * 2:i * 2 + 2], 16) for i in range(len(hex_color) // 2))
-    if len(res) not in (3, 4):
-        breakpoint()
     if len(res) == 4:
         res[3] /= 255
     return tuple(res)

{kevin-toolbox-dev-1.4.8 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/patches/for_matplotlib/common_charts/utils/save_plot.py

@@ -9,3 +9,4 @@ def save_plot(plt, output_path, dpi=200, suffix=".png", **kwargs):
     else:
         os.makedirs(os.path.dirname(output_path), exist_ok=True)
         plt.savefig(output_path, dpi=dpi)
+    plt.close()

{kevin-toolbox-dev-1.4.8 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/patches/for_numpy/linalg/softmax.py

@@ -30,7 +30,7 @@ def softmax(x, axis=-1, temperature=None, b_use_log_over_x=False):
     else:
         # softmax(x)
         # 为了数值稳定，减去最大值
-        x = x - np.max(x)
+        x = x - np.max(x, axis=axis, keepdims=True)
         #
         if temperature is not None:
             assert temperature > 0
@@ -46,3 +46,6 @@ if __name__ == '__main__':
     print(softmax(np.asarray([[[0], [0.1]]]), temperature=0.00001, axis=1))
     print(softmax(np.asarray([[[0], [0.1]]]), temperature=0, axis=1))
     print(softmax([0, 1, 2], temperature=0.1))
+    print(softmax([[5.0000e-01, 5.0000e-01],
+                   [7.0000e-01, 3.0000e-01],
+                   [0.0000e+00, 1.0000e+03]], axis=-1, temperature=None))

kevin-toolbox-dev-1.4.9/kevin_toolbox_dev.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.4.9
+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
+Platform: UNKNOWN
+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.4.9 （2025-03-27）【new feature】【bug fix】
+
+  - patches.for_numpy.linalg
+    - 【bug fix】fix bug in softmax()，修改 33 行，从减去全局最大值改为减去各个分组内部的最大值，避免全局最大值过大导致某些分组全体数值过小导致计算溢出。
+  - patches.for_matplotlib.common_charts.utils
+    - modify save_plot()，在最后增加 plt.close() 用于及时销毁已使用完的画布，避免不必要的内存占用。
+  - nested_dict_list
+    - 【new feature】modify traverse()，增加以下参数以更加精确地控制遍历时的行为：
+      - b_skip_repeated_non_leaf_node:  是否跳过重复的非叶节点。
+        - 何为重复？在内存中的id相同。
+        - 默认为 None，此时将根据 action_mode 的来决定：
+          - 对于会对节点进行修改的模式，比如 "remove" 和 "replace"，将设为 True，以避免预期外的重复转换和替换。
+          - 对于不会修改节点内容的模式，比如 "skip"，将设为 False。
+      - cond_for_repeated_leaf_to_skip：函数列表。在叶节点位置上，遇到满足其中某个条件的重复的元素时需要跳过。
+    - 同步修改内部使用了 traverse() 的 get_nodes() 和 copy_() 等函数。
+    - 新增了对应的测试用例。
+  - data_flow.file.json_
+    - 【bug fix】fix bug in write()。
+      - bug 归因：在 json_.write() 中通过使用 ndl.traverse() 来找出待转换的元素并进行转换，但是在 v1.4.8 前，该函数默认不会跳过重复（在内存中的id相同）出现的内容。由于该内容的不同引用实际上指向的是同一个，因此对这些引用的分别多次操作实际上就是对该内容进行了多次操作。
+      - bug 解决：在后续 v1.4.9 中为 ndl.traverse() 新增了 b_skip_repeated_non_leaf_node 用于控制是否需要跳过重复的引用。我们只需要在使用该函数时，令参数 b_skip_repeated_non_leaf_node=True即可。
+
+

kevin-toolbox-dev-1.4.8/PKG-INFO

@@ -1,81 +0,0 @@
-Metadata-Version: 2.1
-Name: kevin-toolbox-dev
-Version: 1.4.8
-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
-Platform: UNKNOWN
-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.4.8 （2025-03-06）【new feature】【refactor】
-
-  - 【new feature】network，新增网络模块。
-    - 该模块包含网络访问相关的函数：
-      - get_response()，获取 url 的响应。
-      - fetch_metadata()，从 URL/response 中获取文件名、后缀（扩展名）、大小等元信息。
-      - fetch_content()，从 URL/response 中获取内容。
-      - download_file()，下载文件。
-  - env_info
-    - modify Env_Vars_Parser.parse()，新增 default 参数用于支持解释失败时候返回默认值。
-  - computer_science.algorithm
-    - 【refactor】【new feature】decorator，从 developing 中将装饰器相关模块整合到 cs.algorithm 中。
-      - 该目录目前包含以下函数：
-        - retry()，在函数执行失败时，等待一定时间后重试多次。
-        - restore_original_work_path()，在运行函数 func 前备份当前工作目录，并在函数运行结束后还原到原始工作目录。
-    - registration
-      - 【new feature】add Serializer_for_Registry_Execution，用于对基于 Registry 中成员构建的执行过程进行序列化和反序列化操作。
-  - nested_dict_list.serializer
-    - modify write()，增加返回值，返回保存到的路径。
-  - patches.for_matplotlib
-    - 【new feature】add COMMON_CHARTS，增加该注册器用于管理 common_charts 模块中的方法。
-    - common_charts
-      - 为所有plot_xx函数增加了注释和测试用例。
-      - 为所有plot_xx函数增加以下参数：
-        - b_generate_record：是否保存函数参数为档案。
-          - 默认为 False，当设置为 True 时将会把函数参数保存成 [output_path].record.tar。
-          - 后续可以使用 plot_from_record() 函数或者 Serializer_for_Registry_Execution 读取该档案，并进行修改和重新绘制。
-          - 该参数仅在 output_dir 和 output_path 非 None 时起效。
-        - output_path：图片输出路径。
-          - 支持直接指定图片要保存的路径，在原有的通过 output_dir 和 title 自动生成路径的方式之外，提供了另一个指定的方式。
-      - 【new feature】add plot_from_record，从保存的档案 .record.tar 文件中恢复并绘制图像。
-
-

kevin-toolbox-dev-1.4.8/README.md

@@ -1,60 +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.4.8 （2025-03-06）【new feature】【refactor】
-
-  - 【new feature】network，新增网络模块。
-    - 该模块包含网络访问相关的函数：
-      - get_response()，获取 url 的响应。
-      - fetch_metadata()，从 URL/response 中获取文件名、后缀（扩展名）、大小等元信息。
-      - fetch_content()，从 URL/response 中获取内容。
-      - download_file()，下载文件。
-  - env_info
-    - modify Env_Vars_Parser.parse()，新增 default 参数用于支持解释失败时候返回默认值。
-  - computer_science.algorithm
-    - 【refactor】【new feature】decorator，从 developing 中将装饰器相关模块整合到 cs.algorithm 中。
-      - 该目录目前包含以下函数：
-        - retry()，在函数执行失败时，等待一定时间后重试多次。
-        - restore_original_work_path()，在运行函数 func 前备份当前工作目录，并在函数运行结束后还原到原始工作目录。
-    - registration
-      - 【new feature】add Serializer_for_Registry_Execution，用于对基于 Registry 中成员构建的执行过程进行序列化和反序列化操作。
-  - nested_dict_list.serializer
-    - modify write()，增加返回值，返回保存到的路径。
-  - patches.for_matplotlib
-    - 【new feature】add COMMON_CHARTS，增加该注册器用于管理 common_charts 模块中的方法。
-    - common_charts
-      - 为所有plot_xx函数增加了注释和测试用例。
-      - 为所有plot_xx函数增加以下参数：
-        - b_generate_record：是否保存函数参数为档案。
-          - 默认为 False，当设置为 True 时将会把函数参数保存成 [output_path].record.tar。
-          - 后续可以使用 plot_from_record() 函数或者 Serializer_for_Registry_Execution 读取该档案，并进行修改和重新绘制。
-          - 该参数仅在 output_dir 和 output_path 非 None 时起效。
-        - output_path：图片输出路径。
-          - 支持直接指定图片要保存的路径，在原有的通过 output_dir 和 title 自动生成路径的方式之外，提供了另一个指定的方式。
-      - 【new feature】add plot_from_record，从保存的档案 .record.tar 文件中恢复并绘制图像。