kevin-toolbox-dev 1.3.3__tar.gz → 1.3.4__tar.gz

kevin-toolbox-dev-1.3.4/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.3.4
+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.3.4 （2024-04-06）【bug fix】【new feature】
+  - nested_dict_list
+    - 【new feature】add replace_identical_with_reference() to value_parser，新增该函数用于将具有相同 id 的多个节点，替换为单个节点和其多个引用的形式。一般用于去除冗余部分，压缩 ndl 的结构。
+    - 【bug fix】【new feature】fix bug in write()，添加了 saved_node_name_format 参数控制 nodes 下文件名的生成。
+      - bug：在 v1.3.3 前直接使用原始的 node_name 来作为 nodes/ 目录下的文件名，这导致当 node_name 中带有特殊字符时，比如 "/"（在linux下） 和 ":"（在windows下），将会导致保存失败。
+      - fix：使用 saved_node_name_format 指定生成文件名的方式，默认方式 '{count}_{hash_name}' 可以避免出现特殊字符。
+    - 【bug fix】fix bug in write()
+      - bug：在 v1.3.3 前 processed_s 通过 ndl.set_value() 来逐个节点构建，但是由于根据节点名创建的结果可能和原结构存在差异（详见 ndl.set_value() 中b_force参数的介绍），因此导致 processed_s 和 var 结构不一致，导致出错。
+      - fix：使用 ndl.copy_() 来创建结构与 var 一致的 processed_s。
+    - 【new feature】add b_keep_identical_relations to write()，增加该参数用于决定是否保留不同节点之间的 id 相等关系。
+    - 添加了对应的测试用例。
+
+
+

kevin-toolbox-dev-1.3.4/README.md

@@ -0,0 +1,41 @@
+# 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.3.4 （2024-04-06）【bug fix】【new feature】
+  - nested_dict_list
+    - 【new feature】add replace_identical_with_reference() to value_parser，新增该函数用于将具有相同 id 的多个节点，替换为单个节点和其多个引用的形式。一般用于去除冗余部分，压缩 ndl 的结构。
+    - 【bug fix】【new feature】fix bug in write()，添加了 saved_node_name_format 参数控制 nodes 下文件名的生成。
+      - bug：在 v1.3.3 前直接使用原始的 node_name 来作为 nodes/ 目录下的文件名，这导致当 node_name 中带有特殊字符时，比如 "/"（在linux下） 和 ":"（在windows下），将会导致保存失败。
+      - fix：使用 saved_node_name_format 指定生成文件名的方式，默认方式 '{count}_{hash_name}' 可以避免出现特殊字符。
+    - 【bug fix】fix bug in write()
+      - bug：在 v1.3.3 前 processed_s 通过 ndl.set_value() 来逐个节点构建，但是由于根据节点名创建的结果可能和原结构存在差异（详见 ndl.set_value() 中b_force参数的介绍），因此导致 processed_s 和 var 结构不一致，导致出错。
+      - fix：使用 ndl.copy_() 来创建结构与 var 一致的 processed_s。
+    - 【new feature】add b_keep_identical_relations to write()，增加该参数用于决定是否保留不同节点之间的 id 相等关系。
+    - 添加了对应的测试用例。
+

{kevin-toolbox-dev-1.3.3 → kevin-toolbox-dev-1.3.4}/kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.3.3"
+__version__ = "1.3.4"
 
 
 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 1727520805 --verbose 0'
+    f'--expiration_timestamp 1727961379 --verbose 0'
 )

{kevin-toolbox-dev-1.3.3 → kevin-toolbox-dev-1.3.4}/kevin_toolbox/nested_dict_list/serializer/__init__.py

@@ -1,3 +1,4 @@
 from .write import write
 from .read import read
 from .enum_variable import Strictness_Level
+from .saved_node_name_builder import Saved_Node_Name_Builder

{kevin-toolbox-dev-1.3.3 → kevin-toolbox-dev-1.3.4}/kevin_toolbox/nested_dict_list/serializer/read.py

@@ -29,13 +29,15 @@ def read(input_path, **kwargs):
 
     # 读取 var
     var = json_.read(file_path=os.path.join(input_path, "var.json"), b_use_suggested_converter=True)
+    # 读取 record
+    record_s = dict()
+    if os.path.isfile(os.path.join(input_path, "record.json")):
+        record_s = json_.read(file_path=os.path.join(input_path, "record.json"), b_use_suggested_converter=True)
 
     # 读取被处理的节点
     processed_nodes = []
-    if os.path.isfile(os.path.join(input_path, "record.json")):
-        for name, value in ndl.get_nodes(
-                var=json_.read(file_path=os.path.join(input_path, "record.json"),
-                               b_use_suggested_converter=True)["processed"], level=-1, b_strict=True):
+    if record_s:
+        for name, value in ndl.get_nodes(var=record_s["processed"], level=-1, b_strict=True):
             if value:
                 processed_nodes.append(name)
     else:
@@ -56,6 +58,11 @@ def read(input_path, **kwargs):
             bk = SERIALIZER_BACKEND.get(name=value.pop("backend"))(folder=os.path.join(input_path, "nodes"))
             ndl.set_value(var=var, name=name, value=bk.read(**value))
 
+    #
+    if record_s.get("b_keep_identical_relations", False):
+        from kevin_toolbox.nested_dict_list import value_parser
+        var = value_parser.replace_identical_with_reference(var=var, flag="same", b_reverse=True)
+
     #
     if temp_dir is not None:
         for_os.remove(path=temp_dir, ignore_errors=True)

kevin-toolbox-dev-1.3.4/kevin_toolbox/nested_dict_list/serializer/saved_node_name_builder.py

@@ -0,0 +1,31 @@
+class Saved_Node_Name_Builder:
+    """
+        生成保存节点内容时的文件夹/文件名称
+    """
+
+    def __init__(self, format_):
+        try:
+            temp = format_.format(**{k: k + "_" * 3 for k in {"raw_name", "id", "hash_name", "count"}})
+            assert len(temp) > len(format_)
+        except:
+            raise ValueError(f'invalid saved_node_name_format {format_}')
+
+        self.format_ = format_
+        self.count = 0
+
+    def __call__(self, name, value):
+        from kevin_toolbox.nested_dict_list import get_hash
+
+        res = self.format_.format(
+            **{"raw_name": name, "id": id(value), "hash_name": get_hash(name, length=12), "count": self.count})
+        self.count += 1
+        return res
+
+
+if __name__ == '__main__':
+    bd = Saved_Node_Name_Builder(format_="{raw_name}_{count}_{hash_name}_{id}")
+    print(bd(":a@0", 1))
+    print(bd(":b:c", []))
+
+    # bd = Saved_Node_Name_Builder(format_="")
+    # bd = Saved_Node_Name_Builder(format_="{raw_name2}_{count}")

{kevin-toolbox-dev-1.3.3 → kevin-toolbox-dev-1.3.4}/kevin_toolbox/nested_dict_list/serializer/write.py

@@ -7,16 +7,18 @@ from kevin_toolbox.patches import for_os
 import kevin_toolbox.nested_dict_list as ndl
 from kevin_toolbox.nested_dict_list.traverse import Traversal_Mode
 from .enum_variable import Strictness_Level
+from .saved_node_name_builder import Saved_Node_Name_Builder
 
 
 def write(var, output_dir, settings=None, traversal_mode=Traversal_Mode.BFS, b_pack_into_tar=True,
-          strictness_level=Strictness_Level.COMPATIBLE, **kwargs):
+          strictness_level=Strictness_Level.COMPATIBLE, saved_node_name_format='{count}_{hash_name}',
+          b_keep_identical_relations=False, **kwargs):
     """
         将输入的嵌套字典列表 var 的结构和节点值保存到文件中
             遍历 var，匹配并使用 settings 中设置的保存方式来对各部分结构/节点进行序列化
             将会生成一个文件夹或者 .tar 文件，其中包含：
                 - var.json：     用于保存结构、简单节点值、复杂节点值/结构的序列化方式
-                - nodes/目录：    其中包含一系列 <name>.<suffix> 文件或者 <name> 文件夹，其中包含复杂节点值/结构的序列化结果
+                - nodes/：       该目录中包含一系列 <name>.<suffix> 文件或者 <name> 文件夹，其中包含复杂节点值/结构的序列化结果
                 - record.json：   其中记录了：
                                         {
                                             "processed": ... # 对哪些节点/部分进行了处理
@@ -82,25 +84,50 @@ def write(var, output_dir, settings=None, traversal_mode=Traversal_Mode.BFS, b_p
                                             - "low" / Strictness_Level.IGNORE_FAILURE   匹配不完整，或者某些节点尝试过所有匹配到
                                                                                             的 backend 之后仍然无法写入
                                         默认是 "normal"
+            saved_node_name_format: <str> nodes/目录下节点文件/文件夹的命名方式。
+                                        基本结构为：  '{<part_0>}...{<part_1>}...'
+                                        其中 {} 内将根据 part 指定的类型进行自动填充。目前支持以下几种选项：
+                                            - "raw_name"        该节点对应位置的 name。
+                                            - "id"              该节点在当前内存中的 id。
+                                            - "hash_name"       该节点位置 name 的 hash 值。
+                                            - "count"           累加计算，表示是保存的第几个节点。
+                                        ！！注意：
+                                            "raw_name" 该选项在 v1.3.3 前被使用，但是由于其可能含有 : 和 / 等特殊符号，当以其作为文件夹名时，
+                                                可能会引发错误。因此对于 windows 用户，禁止使用该选项，对于 mac 和 linux 用户，同样也不建议使用该选项。
+                                            "id" 虽然具有唯一性，但是其值对于每次运行是随机的。
+                                            "hash_name" 有极低的可能会发生 hash 碰撞。
+                                        综合而言：
+                                            建议使用 "hash_name" 和 "count" 的组合。
+                                        默认值为：
+                                            '{count}_{hash_name}'
+            b_keep_identical_relations: <boolean> 是否保留不同节点之间的 id 相等关系。
+                                        具体而言，就是使用 value_parser.replace_identical_with_reference() 函数将具有相同 id 的多个节点，
+                                            替换为单个节点和其多个引用的形式。
+                                        对于 ndl 中存在大量具有相同 id 的重复节点的情况，使用该操作可以额外达到压缩的效果。
+                                        默认为 False
     """
     from kevin_toolbox.nested_dict_list.serializer.variable import SERIALIZER_BACKEND
 
-    #
+    # 检查参数
     traversal_mode = Traversal_Mode(traversal_mode)
     strictness_level = Strictness_Level(strictness_level)
     os.makedirs(output_dir, exist_ok=True)
     var = ndl.copy_(var=var, b_deepcopy=False)
+    if b_keep_identical_relations:
+        from kevin_toolbox.nested_dict_list import value_parser
+        var = value_parser.replace_identical_with_reference(var=var, flag="same", b_reverse=False)
     if settings is None:
         settings = [{"match_cond": "<level>-1", "backend": (":skip:simple", ":numpy:npy", ":torch:tensor", ":pickle")}]
+    snn_builder = Saved_Node_Name_Builder(format_=saved_node_name_format)
 
     # 构建 processed_s
     #     为了避免重复处理节点/结构，首先构建与 var 具有相似结构的 processed_s 来记录处理处理进度。
     #     对于 processed_s，其节点值为 True 时表示该节点已经被处理，当节点值为 False 或者 list/dict 类型时表示该节点或者节点下面的结构中仍然
     #       存在未处理的部分。
     #     对于中间节点，只有其下所有叶节点都未处理时才会被匹配。
-    processed_s = dict()
+    processed_s = ndl.copy_(var=var, b_deepcopy=False, b_keep_internal_references=False)
     for n, _ in ndl.get_nodes(var=var, level=-1, b_strict=True):
-        ndl.set_value(var=processed_s, name=n, value=False, b_force=True)
+        ndl.set_value(var=processed_s, name=n, value=False, b_force=False)
     # processed_s_bak 用于记录 var 的原始结构
     processed_s_bak = ndl.copy_(var=processed_s, b_deepcopy=True)
     if "_hook_for_debug" in kwargs:
@@ -126,27 +153,21 @@ def write(var, output_dir, settings=None, traversal_mode=Traversal_Mode.BFS, b_p
                 _process = _process_from_top_to_down
             else:
                 _process = _process_from_down_to_top
-            paras = dict(
-                var=var, processed_s=processed_s, match_cond=setting["match_cond"],
-                traversal_mode=t_mode, strictness_level=strictness_level
-            )
+            paras = dict(var=var, match_cond=setting["match_cond"], traversal_mode=t_mode)
         elif setting["match_cond"].startswith("<level>"):
             _process = _process_for_level
-            paras = dict(
-                var=var, processed_s=processed_s, processed_s_bak=processed_s_bak,
-                level=int(setting["match_cond"][7:]), strictness_level=strictness_level
-            )
+            paras = dict(var=var, processed_s_bak=processed_s_bak, level=int(setting["match_cond"][7:]))
         elif setting["match_cond"].startswith("<node>"):
             _process = _process_for_name
-            paras = dict(var=var, processed_s=processed_s, name=setting["match_cond"][6:],
-                         strictness_level=strictness_level)
+            paras = dict(var=var, name=setting["match_cond"][6:])
         else:
             raise ValueError(f'invalid match_cond: {setting["match_cond"]}')
         # 执行
         for i in backend_name_ls:
             # print(processed_s)
             # print(f'backend: {i}')
-            _process(backend=backend_s[i], **paras)
+            _process(backend=backend_s[i], strictness_level=strictness_level, processed_s=processed_s,
+                     snn_builder=snn_builder, **paras)
             if "_hook_for_debug" in kwargs:
                 kwargs["_hook_for_debug"]["processed"].append([i, ndl.copy_(var=processed_s, b_deepcopy=True)])
 
@@ -171,7 +192,8 @@ def write(var, output_dir, settings=None, traversal_mode=Traversal_Mode.BFS, b_p
     json_.write(content=var, file_path=os.path.join(output_dir, "var.json"), b_use_suggested_converter=True)
     # 保存处理结果（非必要）
     json_.write(content=dict(processed=processed_s, raw_structure=processed_s_bak, timestamp=time.time(),
-                             kt_version=kevin_toolbox.__version__),
+                             kt_version=kevin_toolbox.__version__,
+                             b_keep_identical_relations=b_keep_identical_relations),
                 file_path=os.path.join(output_dir, "record.json"), b_use_suggested_converter=True)
 
     # 打包成 .tar 文件
@@ -196,13 +218,13 @@ def _judge_processed_or_not(processed_s, name):
     return b_processed
 
 
-def _process_for_level(var, processed_s, processed_s_bak, level, backend, strictness_level):
+def _process_for_level(var, processed_s, processed_s_bak, level, backend, strictness_level, snn_builder):
     for name, _ in ndl.get_nodes(var=processed_s_bak, level=level, b_strict=True):
         _process_for_name(var=var, processed_s=processed_s, name=name, backend=backend,
-                          strictness_level=strictness_level)
+                          strictness_level=strictness_level, snn_builder=snn_builder)
 
 
-def _process_for_name(var, processed_s, name, backend, strictness_level):
+def _process_for_name(var, processed_s, name, backend, strictness_level, snn_builder):
     if _judge_processed_or_not(processed_s=processed_s, name=name) is True:
         # has been processed
         return
@@ -212,8 +234,9 @@ def _process_for_name(var, processed_s, name, backend, strictness_level):
         return
 
     # write by backend
+    snn_name = snn_builder(name=name, value=value)
     try:
-        res = backend.write(name=name, var=value)
+        res = backend.write(name=snn_name, var=value)
     except:
         assert strictness_level in (Strictness_Level.IGNORE_FAILURE, Strictness_Level.COMPATIBLE), \
             f'An error occurred when node {name} was saved using the first matched backend {backend}'
@@ -222,7 +245,7 @@ def _process_for_name(var, processed_s, name, backend, strictness_level):
     ndl.set_value(var=var, name=name, value=res, b_force=False)
 
 
-def _process_from_top_to_down(var, processed_s, match_cond, backend, traversal_mode, strictness_level):
+def _process_from_top_to_down(var, processed_s, match_cond, backend, traversal_mode, strictness_level, snn_builder):
     def match_cond_(parent_type, idx, value):
         nonlocal match_cond, processed_s
 
@@ -237,8 +260,9 @@ def _process_from_top_to_down(var, processed_s, match_cond, backend, traversal_m
         nonlocal processed_s, backend, strictness_level
 
         # write by backend
+        snn_name = snn_builder(name=idx, value=value)
         try:
-            res = backend.write(name=idx, var=value)
+            res = backend.write(name=snn_name, var=value)
         except:
             assert strictness_level in (Strictness_Level.IGNORE_FAILURE, Strictness_Level.COMPATIBLE), \
                 f'An error occurred when node {name} was saved using the first matched backend {backend}'
@@ -250,7 +274,7 @@ def _process_from_top_to_down(var, processed_s, match_cond, backend, traversal_m
                  b_use_name_as_idx=True, traversal_mode=traversal_mode, b_traverse_matched_element=False)
 
 
-def _process_from_down_to_top(var, processed_s, match_cond, backend, traversal_mode, strictness_level):
+def _process_from_down_to_top(var, processed_s, match_cond, backend, traversal_mode, strictness_level, snn_builder):
     processed_s_raw, processed_s = processed_s, ndl.copy_(var=processed_s, b_deepcopy=True)
 
     def match_cond_(parent_type, idx, value):
@@ -268,8 +292,9 @@ def _process_from_down_to_top(var, processed_s, match_cond, backend, traversal_m
         nonlocal processed_s, backend, processed_s_raw, strictness_level
 
         # write by backend
+        snn_name = snn_builder(name=idx, value=value)
         try:
-            res = backend.write(name=idx, var=value)
+            res = backend.write(name=snn_name, var=value)
         except:
             assert strictness_level in (Strictness_Level.IGNORE_FAILURE, Strictness_Level.COMPATIBLE), \
                 f'An error occurred when node {name} was saved using the first matched backend {backend}'
@@ -305,7 +330,7 @@ if __name__ == '__main__':
         {"match_cond": lambda _, __, value: not isinstance(value, (list, dict)),
          "backend": (":skip:simple",)},
     ]
-    write(var=var_, output_dir=os.path.join(os.path.dirname(__file__), "temp3"), traversal_mode="bfs",
+    write(var=var_, output_dir=os.path.join(os.path.dirname(__file__), "temp"), traversal_mode="bfs",
           b_pack_into_tar=True, settings=settings_, _hook_for_debug=_hook_for_debug)
 
     for bk_name, p in _hook_for_debug["processed"]:

{kevin-toolbox-dev-1.3.3 → kevin-toolbox-dev-1.3.4}/kevin_toolbox/nested_dict_list/value_parser/__init__.py

@@ -2,3 +2,4 @@ from .cal_relation_between_references import cal_relation_between_references
 from .eval_references import eval_references
 from .parse_references import parse_references
 from .parse_and_eval_references import parse_and_eval_references
+from .replace_identical_with_reference import replace_identical_with_reference

kevin-toolbox-dev-1.3.4/kevin_toolbox/nested_dict_list/value_parser/replace_identical_with_reference.py

@@ -0,0 +1,127 @@
+from collections import defaultdict
+from kevin_toolbox.nested_dict_list import get_nodes, get_value, set_value
+from kevin_toolbox.nested_dict_list import value_parser
+
+
+def replace_identical_with_reference(var, flag="same", match_cond=None, b_reverse=False):
+    """
+        将具有相同 id 的多个节点，替换为单个节点和其多个引用的形式
+            一般用于去除冗余部分，压缩 ndl 的结构
+
+        参数：
+            var:
+            flag:                   <str> 引用标记头，表示该节点应该替换为指定节点的内容
+                                        默认为 "same"
+                                        注意，在正向过程中，如果遇到本身就是以该 flag 开头的字符串，会自动在前添加多一个 flag 以示区分，
+                                            然后在逆向过程中，遇到两个 flag 标记开头的字符串将删除一个，然后跳过不处理。
+            match_cond:             <func> 仅对匹配上（返回True视为匹配上）的节点进行处理
+                                        函数类型为 def(name, value)
+                                        其中：
+                                            name            该节点在结构体中的位置
+                                            value           节点的值
+                                        默认不对 int、float、bool、str、None 等类型进行处理
+            b_reverse:              <boolean> 是否进行逆向操作
+    """
+    if match_cond is None:
+        match_cond = lambda name, value: not isinstance(value, (int, float, bool, str, type(None)))
+    assert callable(match_cond)
+
+    if b_reverse:
+        return _reverse(var, flag)
+    else:
+        return _forward(var, flag, match_cond)
+
+
+def _forward(var, flag, match_cond):
+    id_to_height_s = defaultdict(set)
+    id_to_name_s = defaultdict(set)
+    height = 1
+    while True:
+        node_ls = get_nodes(var=var, level=-height, b_strict=True)
+        if not node_ls:
+            break
+        for name, value in node_ls:
+            if not match_cond(name, value):
+                continue
+            id_to_name_s[id(value)].add(name)
+            id_to_height_s[id(value)].add(height)
+        height += 1
+
+    #
+    for k, v in list(id_to_height_s.items()):
+        # 仅保留有多个节点对应的 id
+        if len(id_to_name_s[k]) <= 1:
+            id_to_height_s.pop(k)
+            id_to_name_s.pop(k)
+            continue
+        # 具有相同 id 的节点所处的高度应该相同
+        assert len(v) == 1, f'nodes {id_to_name_s[k]} have different heights: {v}'
+    # 按高度排序
+    id_vs_height = sorted([(k, v.pop()) for k, v in id_to_height_s.items()], key=lambda x: x[1], reverse=True)
+
+    # 从高到低，依次将具有相同 id 的节点替换为 单个节点和多个引用 的形式
+    temp = []
+    processed_name_set = set()
+    for k, _ in id_vs_height:
+        # 找出父节点仍然未被处理的节点（亦即仍然能够访问到的节点）
+        unprocessed_name_set = {n for n in id_to_name_s[k] if id(get_value(var=var, name=n, default=temp)) == k}
+        if len(unprocessed_name_set) <= 1:
+            continue
+        # 任选其一进行保留，其余改为引用
+        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()
+        processed_name_set.update(unprocessed_name_set)
+
+    # 将叶节点中，未被处理过，且是 str，且以 flag 开头的字符串，添加多一个 flag，以示区分
+    for name, value in get_nodes(var=var, level=-1, b_strict=True):
+        if name not in processed_name_set and isinstance(value, str) and value.startswith(f'<{flag}>'):
+            var = set_value(var=var, name=name, value=f'<{flag}>' + value, b_force=False)
+
+    return var
+
+
+class _My_Str:
+    def __init__(self, s):
+        self.s = s
+
+
+def _reverse(var, flag):
+    # 找出叶节点中，带有2个以上 flag 标记的字符串，删除其中一个标记，并使用 _My_Str 包裹，以便与普通引用节点区分
+    for name, value in get_nodes(var=var, level=-1, b_strict=True):
+        if isinstance(value, str) and value.startswith(f'<{flag}><{flag}>'):
+            var = set_value(var=var, name=name, value=_My_Str(value[len(flag) + 2:]), b_force=False)
+    # 解释引用
+    var, _ = value_parser.parse_and_eval_references(var=var, flag=flag)
+    # 解除 _My_Str 包裹
+    for name, value in get_nodes(var=var, level=-1, b_strict=True):
+        if isinstance(value, _My_Str):
+            var = set_value(var=var, name=name, value=value.s, b_force=False)
+    return var
+
+
+if __name__ == '__main__':
+    import numpy as np
+    from kevin_toolbox.nested_dict_list import copy_
+
+    a = np.array([1, 2, 3])
+    b = np.ones((2, 3))
+    c = [a, b]
+    d = {"a": a, "b": b}
+    e = {"c1": c, "c2": c}
+    x = [e, a, d, c, "<same>{@1}", "<same><same>{@1}"]
+
+    print(x)
+
+    y = replace_identical_with_reference(var=copy_(x, b_deepcopy=True), flag="same")
+    print(y)
+
+    x1 = replace_identical_with_reference(var=y, flag="same", b_reverse=True)
+    print(x1)
+
+    from kevin_toolbox.patches.for_test import check_consistency
+
+    check_consistency(x, x1)

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

@@ -0,0 +1,62 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.3.4
+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.3.4 （2024-04-06）【bug fix】【new feature】
+  - nested_dict_list
+    - 【new feature】add replace_identical_with_reference() to value_parser，新增该函数用于将具有相同 id 的多个节点，替换为单个节点和其多个引用的形式。一般用于去除冗余部分，压缩 ndl 的结构。
+    - 【bug fix】【new feature】fix bug in write()，添加了 saved_node_name_format 参数控制 nodes 下文件名的生成。
+      - bug：在 v1.3.3 前直接使用原始的 node_name 来作为 nodes/ 目录下的文件名，这导致当 node_name 中带有特殊字符时，比如 "/"（在linux下） 和 ":"（在windows下），将会导致保存失败。
+      - fix：使用 saved_node_name_format 指定生成文件名的方式，默认方式 '{count}_{hash_name}' 可以避免出现特殊字符。
+    - 【bug fix】fix bug in write()
+      - bug：在 v1.3.3 前 processed_s 通过 ndl.set_value() 来逐个节点构建，但是由于根据节点名创建的结果可能和原结构存在差异（详见 ndl.set_value() 中b_force参数的介绍），因此导致 processed_s 和 var 结构不一致，导致出错。
+      - fix：使用 ndl.copy_() 来创建结构与 var 一致的 processed_s。
+    - 【new feature】add b_keep_identical_relations to write()，增加该参数用于决定是否保留不同节点之间的 id 相等关系。
+    - 添加了对应的测试用例。
+
+
+

{kevin-toolbox-dev-1.3.3 → kevin-toolbox-dev-1.3.4}/kevin_toolbox_dev.egg-info/SOURCES.txt

@@ -234,6 +234,7 @@ kevin_toolbox/nested_dict_list/name_handler/parse_name.py
 kevin_toolbox/nested_dict_list/serializer/__init__.py
 kevin_toolbox/nested_dict_list/serializer/enum_variable.py
 kevin_toolbox/nested_dict_list/serializer/read.py
+kevin_toolbox/nested_dict_list/serializer/saved_node_name_builder.py
 kevin_toolbox/nested_dict_list/serializer/variable.py
 kevin_toolbox/nested_dict_list/serializer/write.py
 kevin_toolbox/nested_dict_list/serializer/backends/__init__.py
@@ -252,6 +253,7 @@ kevin_toolbox/nested_dict_list/value_parser/cal_relation_between_references.py
 kevin_toolbox/nested_dict_list/value_parser/eval_references.py
 kevin_toolbox/nested_dict_list/value_parser/parse_and_eval_references.py
 kevin_toolbox/nested_dict_list/value_parser/parse_references.py
+kevin_toolbox/nested_dict_list/value_parser/replace_identical_with_reference.py
 kevin_toolbox/patches/__init__.py
 kevin_toolbox/patches/for_logging/__init__.py
 kevin_toolbox/patches/for_logging/build_logger.py

kevin-toolbox-dev-1.3.3/PKG-INFO

@@ -1,70 +0,0 @@
-Metadata-Version: 2.1
-Name: kevin-toolbox-dev
-Version: 1.3.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
-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.3.3 （2024-04-01）【bug fix】【new feature】
-  - math.utils
-    - 【bug fix】更正拼写错误，将原有的 spilt_integer_most_evenly() 中的 "spilt" 改正为 "split"，新的函数名为 split_integer_most_evenly
-
-  - patches.for_numpy.random
-    - 【bug fix】modify get_rng()，改进以避免遇到 rng 中不存在的函数时报错。
-
-  - data_flow.file
-    - json_
-      - 【new feature】将 escape_tuple() 改成 escape_tuple_and_set()，新增对 set 进行处理。
-      - 【new feature】将 unescape_tuple() 改成 unescape_tuple_and_set()。
-
-    - core.reader
-      - 【new feature】为 File_Iterative_Reader 新增了 file_obj 参数，支持直接输入文件对象。
-
-    - kevin_notation
-      - 【new feature】根据 File_Iterative_Reader 的修改，为 Kevin_Notation_Reader 和 read() 对应增加 file_obj 参数，以支持直接输入文件对象。
-      - 补充了对应的测试用例。
-
-
-
-