kevin-toolbox-dev 1.4.4__tar.gz → 1.4.5__tar.gz

kevin-toolbox-dev-1.4.5/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.4.5
+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.5 （2024-12-22）【bug fix】【new feature】
+  - data_flow.file.json_
+    - modify write()，支持输入路径使用 ~ 表示家目录。
+  - env_info
+    - 【new feature】add variable_，该模块主要包含于处理环境变量相关的函数和类。
+      - Env_Vars_Parser：解释并替换字符串中${}形式指定的环境变量，支持以下几种方式：
+        - "${HOME}"                 家目录
+        -  "${SYS:<var_name>}"       其他系统环境变量
+        - "${KVT_XXX<ndl_name>}"   读取配置文件 ~/.kvt_cfg/.xxx.json 中的变量（xxx将被自动转为小写）
+        - "${/xxx.../xxx.json<ndl_name>}"  读取指定路径下的配置文件 /xxx.../xxx.json 中的变量
+      - env_vars_parser：类 Env_Vars_Parser 的默认实例
+    - 添加了对应的测试用例。
+  - nested_dict_list
+    - 【new feature】modify get_value() and set_value() for parsed_name input，在字符串name的基础上，进一步支持使用结构化的(root_node, method_ls, node_ls)形式的name作为输入。
+      - 相较于字符串形式的name，结构化的name因不用解释而效率更高，推荐使用。
+    - 【new feature】modify serializer.read() and write()，支持通过 nodes_dir 指定节点内容保存在哪个目录下，同时支持在 settings 中为每个处理模式单独指定其使用的 nodes_dir 和 saved_node_name_format。
+      - 有了该功能，允许多个ndl文件共享多个节点内容，形式更加自由。
+    - 添加了对应的测试用例。
+
+

kevin-toolbox-dev-1.4.5/README.md

@@ -0,0 +1,47 @@
+# 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.5 （2024-12-22）【bug fix】【new feature】
+  - data_flow.file.json_
+    - modify write()，支持输入路径使用 ~ 表示家目录。
+  - env_info
+    - 【new feature】add variable_，该模块主要包含于处理环境变量相关的函数和类。
+      - Env_Vars_Parser：解释并替换字符串中${}形式指定的环境变量，支持以下几种方式：
+        - "${HOME}"                 家目录
+        -  "${SYS:<var_name>}"       其他系统环境变量
+        - "${KVT_XXX<ndl_name>}"   读取配置文件 ~/.kvt_cfg/.xxx.json 中的变量（xxx将被自动转为小写）
+        - "${/xxx.../xxx.json<ndl_name>}"  读取指定路径下的配置文件 /xxx.../xxx.json 中的变量
+      - env_vars_parser：类 Env_Vars_Parser 的默认实例
+    - 添加了对应的测试用例。
+  - nested_dict_list
+    - 【new feature】modify get_value() and set_value() for parsed_name input，在字符串name的基础上，进一步支持使用结构化的(root_node, method_ls, node_ls)形式的name作为输入。
+      - 相较于字符串形式的name，结构化的name因不用解释而效率更高，推荐使用。
+    - 【new feature】modify serializer.read() and write()，支持通过 nodes_dir 指定节点内容保存在哪个目录下，同时支持在 settings 中为每个处理模式单独指定其使用的 nodes_dir 和 saved_node_name_format。
+      - 有了该功能，允许多个ndl文件共享多个节点内容，形式更加自由。
+    - 添加了对应的测试用例。

{kevin-toolbox-dev-1.4.4 → kevin-toolbox-dev-1.4.5}/kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.4.4"
+__version__ = "1.4.5"
 
 
 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 1749817728 --verbose 0'
+    f'--expiration_timestamp 1750434037 --verbose 0'
 )

{kevin-toolbox-dev-1.4.4 → kevin-toolbox-dev-1.4.5}/kevin_toolbox/data_flow/file/json_/write_json.py

@@ -38,9 +38,9 @@ def write_json(content, file_path, sort_keys=False, converters=None, b_use_sugge
     content = json.dumps(content, indent=4, ensure_ascii=False, sort_keys=sort_keys)
 
     if file_path is not None:
-        file_path = os.path.abspath(file_path)
+        file_path = os.path.abspath(os.path.expanduser(file_path))
         os.makedirs(os.path.dirname(file_path), exist_ok=True)
-        with open(file_path, 'w') as f:
+        with open(file_path, 'w', encoding="utf-8") as f:
             f.write(content)
     else:
         return content

kevin-toolbox-dev-1.4.5/kevin_toolbox/env_info/test/test_variable_.py

@@ -0,0 +1,50 @@
+import os
+import pytest
+from kevin_toolbox.env_info.variable_ import Env_Vars_Parser
+from kevin_toolbox.patches.for_test import check_consistency
+
+
+@pytest.mark.parametrize(
+    "input_text, expected",
+    [
+        # 验证 ${<cfg_name>:<var_name>} 的情况
+        (
+                "666/123${SYS:HOME}/afasf/${/xxx.../xxx.json:111:222}336",
+                ["666/123", ("SYS", [':'], ['HOME']), "/afasf/", ("/xxx.../xxx.json", [':', ':'], ['111', '222']),
+                 "336"]
+        ),
+        # 验证 ${<cfg_name>} 和 ${:<var_name>} 的混合情况
+        (
+                "start${CFG}middle${:VAR}end",
+                ["start", ("CFG", [], []), "middle", ('', [':'], ['VAR']), "end"]
+        ),
+        (
+                "${:VAR}",
+                [('', [':'], ['VAR'])]
+        ),
+        (
+                "${CFG}",
+                [("CFG", [], [])]
+        ),
+        (
+                "{:VAR}",
+                ["{:VAR}"]
+        ),
+    ]
+)
+def test_split_string_in_env_vars_parser(input_text, expected):
+    result = Env_Vars_Parser.split_string(input_text)
+    check_consistency(result, expected)
+
+
+def test_env_vars_parser_0():
+    env_cfg_file = os.path.expanduser("~/.kvt_cfg/.temp.json")
+    from kevin_toolbox.data_flow.file import json_
+    json_.write(content={"dataset_dir": ["~/data", "~/dataset"], "version": "001"}, file_path=env_cfg_file)
+    input_text = "/root/${KVT_TEMP:dataset_dir@1}/${KVT_TEMP:version}/${HOME}/${SYS:HOME}"
+    expected = "/".join(["/root/~/dataset/001", ] + [os.path.expanduser("~")] * 2)
+
+    #
+    parser = Env_Vars_Parser()
+    result = parser(input_text)
+    check_consistency(expected, result)

kevin-toolbox-dev-1.4.5/kevin_toolbox/env_info/variable_/__init__.py

@@ -0,0 +1,2 @@
+from .env_vars_parser import Env_Vars_Parser
+env_vars_parser = Env_Vars_Parser()

kevin-toolbox-dev-1.4.5/kevin_toolbox/env_info/variable_/env_vars_parser.py

@@ -0,0 +1,88 @@
+import os
+import re
+from kevin_toolbox.data_flow.file import json_
+
+
+class Env_Vars_Parser:
+    """
+        解释并替换字符串中${}形式指定的环境变量
+            支持以下几种方式：
+            - "${HOME}"                 家目录
+            - "${SYS:<var_name>}"       其他系统环境变量
+                                            在 linux 系统可以通过 env 命令来打印当前的环境变量，比如家目录也可以使用 ${SYS:HOME} 来表示
+            - "${KVT_XXX<ndl_name>}"   读取配置文件 ~/.kvt_cfg/.xxx.json 中的变量（xxx将被自动转为小写）
+                                            配置文件要求是 ndl 结构，比如当配置文件 ~/.kvt_cfg/.ndl.json 中保存的值为：
+                                                {"dataset_dir":["~/data", "~/dataset"], ...}
+                                            时，如果要指定使用 dataset_dir 下第二个路径，那么可以使用 ${KVT_NDL:dataset_dir@1} 来表示
+            - "${/xxx.../xxx.json<ndl_name>}"  读取指定路径下的配置文件 /xxx.../xxx.json 中的变量
+    """
+
+    def __init__(self, home_dir=None):
+        self.cfg_s = dict(
+            SYS=dict(os.environ),
+            HOME=home_dir if home_dir is not None else os.path.expanduser("~")
+        )
+
+    def __call__(self, *args, **kwargs):
+        return self.parse(*args, **kwargs)
+
+    def parse(self, text):
+        """
+            解释并替换
+        """
+        temp_ls = []
+        for it in self.split_string(text=text):
+            if isinstance(it, str):
+                temp_ls.append(it)
+                continue
+            root_node, method_ls, node_ls = it
+            if root_node not in self.cfg_s:
+                try:
+                    if root_node.startswith("KVT_"):
+                        t0, t1 = root_node.lower().split("_", 1)
+                        root_node = os.path.expanduser(f'~/.{t0}_cfg/.{t1}.json')
+                    assert os.path.isfile(root_node), f'file not exist: {root_node}'
+                    cfg = json_.read(file_path=root_node, b_use_suggested_converter=True)
+                    self.cfg_s[root_node] = cfg
+                except Exception as e:
+                    raise ValueError(f"invalid cfg_name: {root_node}, because: {e}")
+            cfg = self.cfg_s.get(root_node, None)
+            if cfg is None:
+                raise ValueError(f"invalid cfg_name: {root_node}")
+            #
+            from kevin_toolbox.nested_dict_list import get_value
+            temp_ls.append(get_value(var=cfg, name=it))
+
+        return "".join([f'{i}' for i in temp_ls])
+
+    @staticmethod
+    def split_string(text):
+        """
+            将字符串中 ${<cfg_name>} 部分的内容分割出来
+                比如对于 "666/123${SYS:HOME}/afasf/${/xxx.../xxx.json:111:222}336"
+                应该分割为 ["666/123", ("SYS:HOME", ), "/afasf/", ("/xxx.../xxx.json:111:222", ), "336"]
+                然后再对其中 tuple 部分使用 ndl.name_handler.parse_name 进行解释
+        """
+        from kevin_toolbox.nested_dict_list.name_handler import parse_name
+        pattern = r'\$\{([^}]+)\}'
+        matches = re.finditer(pattern, text)
+
+        result = []
+        last_end = 0
+
+        for match in matches:
+            start = match.start()
+            if start > last_end:
+                result.append(text[last_end:start])
+            result.append(parse_name(name=match.group(1)))
+            last_end = match.end()
+
+        if last_end < len(text):
+            result.append(text[last_end:])
+
+        return result
+
+
+if __name__ == '__main__':
+    env_vars_parser = Env_Vars_Parser()
+    print(env_vars_parser.split_string("666/123${:VAR}/afasf/${/xxx.../xxx.json:111:222}336"))

{kevin-toolbox-dev-1.4.4 → kevin-toolbox-dev-1.4.5}/kevin_toolbox/nested_dict_list/get_value.py

@@ -7,7 +7,7 @@ def get_value(var, name, b_pop=False, **kwargs):
 
         参数：
             var:            任意支持索引取值的变量
-            name:           <str> 名字
+            name:           <str/parsed_name> 名字
                                 名字 name 的具体介绍参见函数 name_handler.parse_name()
                                 假设 var=dict(acc=[0.66,0.78,0.99])，如果你想读取 var["acc"][1] => 0.78，那么可以将 name 写成：
                                     ":acc@1" 或者 "|acc|1" 等。
@@ -19,7 +19,11 @@ def get_value(var, name, b_pop=False, **kwargs):
                                 - 不设置（默认）。当取值失败时将报错。
                                 - 设置为任意值。取值失败时将返回该值。
     """
-    _, method_ls, node_ls = parse_name(name=name, b_de_escape_node=True)
+    if isinstance(name, (tuple, list,)):
+        assert len(name) == 3, f'invalid parsed name {name}'
+        _, method_ls, node_ls = name
+    else:
+        _, method_ls, node_ls = parse_name(name=name, b_de_escape_node=True)
 
     try:
         pre, cur = None, var
@@ -46,3 +50,9 @@ def get_value(var, name, b_pop=False, **kwargs):
             raise IndexError(f'invalid name {name}')
 
     return cur
+
+
+if __name__ == "__main__":
+    var_ = dict(acc=[0.66, 0.78, 0.99])
+    print(get_value(var_, ''))
+    print(get_value(var_, ['', [], []]))

{kevin-toolbox-dev-1.4.4 → kevin-toolbox-dev-1.4.5}/kevin_toolbox/nested_dict_list/serializer/read.py

@@ -1,9 +1,9 @@
 import os
-import time
+import tempfile
 from kevin_toolbox.patches import for_os
 from kevin_toolbox.data_flow.file import json_
 import kevin_toolbox.nested_dict_list as ndl
-import tempfile
+from kevin_toolbox.env_info.variable_ import env_vars_parser
 
 
 def read(input_path, **kwargs):
@@ -13,8 +13,6 @@ def read(input_path, **kwargs):
         参数：
             input_path:             <path> 文件夹或者 .tar 文件，具体结构参考 write()
     """
-    from kevin_toolbox.nested_dict_list.serializer.variable import SERIALIZER_BACKEND
-
     assert os.path.exists(input_path)
 
     with tempfile.TemporaryDirectory(dir=os.path.dirname(input_path)) as temp_dir:
@@ -63,7 +61,10 @@ def _read_unpacked_ndl(input_path, **kwargs):
     for name in processed_nodes:
         value = ndl.get_value(var=var, name=name)
         if isinstance(value, (dict,)) and "backend" in value and "name" in value:
-            bk = SERIALIZER_BACKEND.get(name=value.pop("backend"))(folder=os.path.join(input_path, "nodes"))
+            nodes_dir = env_vars_parser(value.pop("nodes_dir")) if "nodes_dir" in value else os.path.join(input_path,
+                                                                                                          "nodes")
+            assert os.path.exists(nodes_dir), f"nodes_dir {nodes_dir} does not exist"
+            bk = SERIALIZER_BACKEND.get(name=value.pop("backend"))(folder=nodes_dir)
             ndl.set_value(var=var, name=name, value=bk.read(**value))
 
     #

{kevin-toolbox-dev-1.4.4 → kevin-toolbox-dev-1.4.5}/kevin_toolbox/nested_dict_list/serializer/write.py

@@ -7,6 +7,7 @@ from kevin_toolbox.data_flow.file import json_
 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 kevin_toolbox.env_info.variable_ import env_vars_parser
 from .enum_variable import Strictness_Level
 from .saved_node_name_builder import Saved_Node_Name_Builder
 
@@ -32,7 +33,17 @@ def write(var, output_dir, settings=None, traversal_mode=Traversal_Mode.BFS, b_p
             var:                    <nested dict list>
             settings:               <list of dict> 指定对于不同节点or部分的处理模式
                                         其结构为：
-                                            [{"match_cond": <匹配模式>, "backend": <序列化方式>, "traversal_mode": <遍历方式>}, ...]
+                                            [
+                                                {
+                                                    "match_cond": <匹配模式>,
+                                                    "backend": <序列化方式>,
+                                                    "traversal_mode": <遍历方式>,
+                                                    ("nodes_dir": <节点保存目录>,
+                                                     "saved_node_name_format": <nodes目录下节点文件/文件夹的命名方式>)
+                                                },
+                                                ...
+                                            ]
+                                        允许专门指定某个处理模式下所使用的 nodes_dir 和 saved_node_name_format，若不指定，则使用后面的默认值。
                                         <匹配模式>支持以下4种：
                                             - "<level>..."  匹配指定层的节点，比如"<level>0"表示根节点，"<level>-1"表示所有叶节点
                                             - "<node>name"  匹配指定name的节点
@@ -85,7 +96,9 @@ 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/目录下节点文件/文件夹的命名方式。
+            nodes_dir:              <path> 节点内容保存目录
+                                        默认为保存在 <output_dir>/nodes 下
+            saved_node_name_format: <str> nodes目录下节点文件/文件夹的命名方式。
                                         基本结构为：  '{<part_0>}...{<part_1>}...'
                                         其中 {} 内将根据 part 指定的类型进行自动填充。目前支持以下几种选项：
                                             - "raw_name"        该节点对应位置的 name。
@@ -132,7 +145,8 @@ def write(var, output_dir, settings=None, traversal_mode=Traversal_Mode.BFS, b_p
         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)
+    default_snn_builder = Saved_Node_Name_Builder(format_=saved_node_name_format)
+    default_nodes_dir = os.path.join(temp_output_dir, "nodes")
 
     # 构建 processed_s
     #     为了避免重复处理节点/结构，首先构建与 var 具有相似结构的 processed_s 来记录处理处理进度。
@@ -154,13 +168,20 @@ def write(var, output_dir, settings=None, traversal_mode=Traversal_Mode.BFS, b_p
         if isinstance(setting["match_cond"], str) and setting["match_cond"].startswith("<eval>"):
             setting["match_cond"] = eval(setting["match_cond"][6:])
         assert callable(setting["match_cond"]) or isinstance(setting["match_cond"], str)
+        # nodes_dir = env_vars_parser(value.pop("nodes_dir")) if "nodes_dir" in value else os.path.join(input_path,
+        #                                                                                               "nodes")
+        # assert os.path.exists(nodes_dir), f"nodes_dir {nodes_dir} does not exist"
         # backend
         backend_name_ls = setting["backend"] if isinstance(setting["backend"], (list, tuple)) else [setting["backend"]]
+        nodes_dir = env_vars_parser(setting["nodes_dir"]) if "nodes_dir" in setting else default_nodes_dir
         for i in backend_name_ls:
             if i not in backend_s:
-                backend_s[i] = SERIALIZER_BACKEND.get(name=i)(folder=os.path.join(temp_output_dir, "nodes"))
+                backend_s[i] = SERIALIZER_BACKEND.get(name=i)(folder=nodes_dir)
         #
         t_mode = Traversal_Mode(setting.get("traversal_mode", traversal_mode))
+        # snn_builder
+        snn_builder = Saved_Node_Name_Builder(
+            format_=setting["saved_node_name_format"]) if "saved_node_name_format" in setting else default_snn_builder
         # _process and  paras
         if callable(setting["match_cond"]):
             if t_mode in (Traversal_Mode.DFS_PRE_ORDER, Traversal_Mode.BFS):
@@ -181,7 +202,7 @@ def write(var, output_dir, settings=None, traversal_mode=Traversal_Mode.BFS, b_p
             # print(processed_s)
             # print(f'backend: {i}')
             _process(backend=backend_s[i], strictness_level=strictness_level, processed_s=processed_s,
-                     snn_builder=snn_builder, **paras)
+                     snn_builder=snn_builder, b_record_nodes_dir=nodes_dir != default_nodes_dir, **paras)
             if "_hook_for_debug" in kwargs:
                 kwargs["_hook_for_debug"]["processed"].append([i, ndl.copy_(var=processed_s, b_deepcopy=True)])
 
@@ -246,13 +267,29 @@ 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, snn_builder):
+def _process_for_level(var, processed_s, processed_s_bak, level, backend, strictness_level, snn_builder,
+                       b_record_nodes_dir):
     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, snn_builder=snn_builder)
+                          strictness_level=strictness_level, snn_builder=snn_builder,
+                          b_record_nodes_dir=b_record_nodes_dir)
 
 
-def _process_for_name(var, processed_s, name, backend, strictness_level, snn_builder):
+def _write_by_backend(backend, snn_builder, raw_name, value, strictness_level, b_record_nodes_dir):
+    snn_name = snn_builder(name=raw_name, value=value)
+    try:
+        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 {snn_name} was saved using the first matched backend {backend}'
+        return False, None  # b_success, res
+    if b_record_nodes_dir and isinstance(res, (dict,)) and res is not value:
+        # 记录节点位置
+        res["nodes_dir"] = backend.paras["folder"]
+    return True, res
+
+
+def _process_for_name(var, processed_s, name, backend, strictness_level, snn_builder, b_record_nodes_dir):
     if _judge_processed_or_not(processed_s=processed_s, name=name) is True:
         # has been processed
         return
@@ -262,18 +299,15 @@ def _process_for_name(var, processed_s, name, backend, strictness_level, snn_bui
         return
 
     # write by backend
-    snn_name = snn_builder(name=name, value=value)
-    try:
-        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}'
+    b_success, res = _write_by_backend(backend, snn_builder, name, value, strictness_level, b_record_nodes_dir)
+    if not b_success:
         return
     ndl.set_value(var=processed_s, name=name, value=True, b_force=False)
     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, snn_builder):
+def _process_from_top_to_down(var, processed_s, match_cond, backend, traversal_mode, strictness_level, snn_builder,
+                              b_record_nodes_dir):
     def match_cond_(parent_type, idx, value):
         nonlocal match_cond, processed_s
 
@@ -288,12 +322,8 @@ 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=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}'
+        b_success, res = _write_by_backend(backend, snn_builder, idx, value, strictness_level, b_record_nodes_dir)
+        if not b_success:
             return value
         ndl.set_value(var=processed_s, name=idx, value=True, b_force=True)
         return res
@@ -302,7 +332,8 @@ 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, snn_builder):
+def _process_from_down_to_top(var, processed_s, match_cond, backend, traversal_mode, strictness_level, snn_builder,
+                              b_record_nodes_dir):
     processed_s_raw, processed_s = processed_s, ndl.copy_(var=processed_s, b_deepcopy=True)
 
     def match_cond_(parent_type, idx, value):
@@ -320,12 +351,8 @@ 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=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}'
+        b_success, res = _write_by_backend(backend, snn_builder, idx, value, strictness_level, b_record_nodes_dir)
+        if not b_success:
             return value
         ndl.set_value(var=processed_s, name=idx, value=True, b_force=True)
         ndl.set_value(var=processed_s_raw, name=idx, value=True, b_force=True)

{kevin-toolbox-dev-1.4.4 → kevin-toolbox-dev-1.4.5}/kevin_toolbox/nested_dict_list/set_value.py

@@ -1,5 +1,5 @@
 from kevin_toolbox.nested_dict_list import get_value
-from kevin_toolbox.nested_dict_list.name_handler import parse_name, escape_node
+from kevin_toolbox.nested_dict_list.name_handler import parse_name
 
 
 def set_value(var, name, value, b_force=False):
@@ -8,7 +8,7 @@ def set_value(var, name, value, b_force=False):
 
         参数：
             var:            任意支持索引赋值的变量
-            name:           <string> 名字
+            name:           <string/parsed_name> 名字
                                 名字 name 的具体介绍参见函数 name_handler.parse_name()
                                 假设 var=dict(acc=[0.66,0.78,0.99])，如果你想将 var["acc"][1] 设置为 100，那么可以将 name 写成：
                                     ":acc@1" 或者 "|acc|1" 等。
@@ -25,14 +25,18 @@ def set_value(var, name, value, b_force=False):
                     若 b_force 为 True 有可能不会在 var 的基础上进行改变，而是返回一个新的ndl结构，
                     因此建议使用赋值 var = ndl.set_value(var) 来避免可能的错误。
     """
-    _, method_ls, node_ls = parse_name(name=name, b_de_escape_node=False)
+    if isinstance(name, (tuple, list,)):
+        assert len(name) == 3, f'invalid parsed name {name}'
+        _, method_ls, node_ls = name
+    else:
+        _, method_ls, node_ls = parse_name(name=name, b_de_escape_node=True)
     if len(node_ls) == 0:
         return value
 
-    raw_key = escape_node(node=node_ls[-1], b_reversed=True, times=1)
+    raw_key = node_ls[-1]
 
     try:
-        item = get_value(var=var, name=name[:-1 - len(node_ls[-1])])
+        item = get_value(var=var, name=('', method_ls[:-1], node_ls[:-1]))
         if method_ls[-1] == "@":
             key = eval(raw_key)
         elif method_ls[-1] == "|":
@@ -63,6 +67,12 @@ def set_value(var, name, value, b_force=False):
                 else:
                     # 其他，比如当 key 为元组、浮点数等等时，则使用 dict 构建
                     value = {key: value}
-            var = set_value(var=var, name=name[:-1 - len(node_ls[-1])], value=value, b_force=b_force)
+            var = set_value(var=var, name=('', method_ls[:-1], node_ls[:-1]), value=value, b_force=b_force)
 
     return var
+
+
+if __name__ == "__main__":
+    var_ = []
+    set_value(var=var_, name="@2:data", value=1, b_force=True)
+    print(var_)

kevin-toolbox-dev-1.4.5/kevin_toolbox/utils/variable.py

@@ -0,0 +1,6 @@
+import os
+
+root_dir = os.path.split(os.path.split(os.path.split(__file__)[0])[0])[0]
+
+if __name__ == '__main__':
+    print(root_dir)

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

@@ -0,0 +1,68 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.4.5
+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.5 （2024-12-22）【bug fix】【new feature】
+  - data_flow.file.json_
+    - modify write()，支持输入路径使用 ~ 表示家目录。
+  - env_info
+    - 【new feature】add variable_，该模块主要包含于处理环境变量相关的函数和类。
+      - Env_Vars_Parser：解释并替换字符串中${}形式指定的环境变量，支持以下几种方式：
+        - "${HOME}"                 家目录
+        -  "${SYS:<var_name>}"       其他系统环境变量
+        - "${KVT_XXX<ndl_name>}"   读取配置文件 ~/.kvt_cfg/.xxx.json 中的变量（xxx将被自动转为小写）
+        - "${/xxx.../xxx.json<ndl_name>}"  读取指定路径下的配置文件 /xxx.../xxx.json 中的变量
+      - env_vars_parser：类 Env_Vars_Parser 的默认实例
+    - 添加了对应的测试用例。
+  - nested_dict_list
+    - 【new feature】modify get_value() and set_value() for parsed_name input，在字符串name的基础上，进一步支持使用结构化的(root_node, method_ls, node_ls)形式的name作为输入。
+      - 相较于字符串形式的name，结构化的name因不用解释而效率更高，推荐使用。
+    - 【new feature】modify serializer.read() and write()，支持通过 nodes_dir 指定节点内容保存在哪个目录下，同时支持在 settings 中为每个处理模式单独指定其使用的 nodes_dir 和 saved_node_name_format。
+      - 有了该功能，允许多个ndl文件共享多个节点内容，形式更加自由。
+    - 添加了对应的测试用例。
+
+