kevin-toolbox-dev 1.2.7__py3-none-any.whl → 1.3.0__py3-none-any.whl

kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.2.7"
+__version__ = "1.3.0"
 
 
 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 1710582827 --verbose 0'
+    f'--expiration_timestamp 1718018144 --verbose 0'
 )

kevin_toolbox/computer_science/algorithm/registration/registry.py

@@ -4,6 +4,8 @@ import inspect
 import pkgutil
 import weakref
 import kevin_toolbox.nested_dict_list as ndl
+from kevin_toolbox.patches import for_os
+from kevin_toolbox.patches.for_os import Path_Ignorer, Ignore_Scope
 
 
 class Registry:
@@ -218,14 +220,22 @@ class Registry:
 
     # -------------------- 通过路径添加 --------------------- #
 
-    def collect_from_paths(self, path_ls=None, path_ls_to_exclude=None, b_execute_now=False):
+    def collect_from_paths(self, path_ls=None, ignore_s=None, b_execute_now=False):
         """
             遍历 path_ls 下的所有模块，并自动导入其中主要被注册的部分
                 比如被 register() 装饰器包裹或者通过 add() 添加的部分
 
             参数：
                 path_ls:            <list of paths> 需要搜索的目录
-                path_ls_to_exclude: <list of paths> 需要排除的目录
+                ignore_s:           <list/tuple of dict> 在搜索遍历目录时候要执行的排除规则
+                                        具体设置方式参考 patches.for_os.walk() 中的 ignore_s 参数。
+                                        比如使用下面的规则就可以排除待搜索目录下的所有 temp/ 和 test/ 文件夹：
+                                        [
+                                            {
+                                                "func": lambda _, __, path: os.path.basename(path) in ["temp", "test"],
+                                                "scope": ["root", "dirs"]
+                                            },
+                                        ]
                 b_execute_now:      <boolean> 现在就执行导入
                                         默认为 False，将等到第一次执行 get() 函数时才会真正尝试导入
 
@@ -243,10 +253,13 @@ class Registry:
             f'calling Registry.collect_from_paths() in __init__.py is forbidden, file: {caller_frame.filename}.\n' \
             f'you can call it in other files, and then import the result of the call in __init__.py'
 
+        # 根据 ignore_s 构建 Path_Ignorer
+        path_ignorer = ignore_s if isinstance(ignore_s, (Path_Ignorer,)) else Path_Ignorer(ignore_s=ignore_s)
+
         #
         if not b_execute_now:
             self._path_to_collect.append(
-                dict(path_ls=path_ls, path_ls_to_exclude=path_ls_to_exclude, b_execute_now=True))
+                dict(path_ls=path_ls, ignore_s=path_ignorer, b_execute_now=True))
             return
 
         #
@@ -254,27 +267,38 @@ class Registry:
             temp = []
             for path in filter(lambda x: os.path.isdir(x), path_ls):
                 temp.append(path)
-                for root, dirs, _ in os.walk(path, topdown=False):
+                for root, dirs, _ in for_os.walk(path, topdown=False, ignore_s=path_ignorer, followlinks=True):
                     temp.extend([os.path.join(root, i) for i in dirs])
-            if path_ls_to_exclude is not None:
-                for path_ex in path_ls_to_exclude:
-                    if not os.path.exists(path_ex):
-                        continue
-                    for i in reversed(range(len(temp))):
-                        if os.path.samefile(os.path.commonpath([path_ex, temp[i]]), path_ex):
-                            temp.pop(i)
             # 从深到浅导入，可以避免继承引起的 TypeError: super(type, obj) 类型错误
             path_ls = list(set(temp))
             path_ls.sort(reverse=True)
+        path_set = set(path_ls)
 
         temp = None
         for loader, module_name, is_pkg in pkgutil.walk_packages(path_ls):
+            # 判断该模块是否需要导入
+            #   （快速判断）判断该模块所在目录是否在 path_set 中
+            if loader.path not in path_set:
+                continue
+            if is_pkg:
+                #   若不是 package，判断是否满足 Path_Ignorer 中的 dirs 对应的规则
+                path = os.path.dirname(loader.find_module(module_name).path)
+                if path_ignorer(Ignore_Scope.DIRS, True, os.path.islink(path), path):
+                    continue
+            else:
+                #   若该模块是 package，判断该模块的文件路径是否满足 Path_Ignorer 中的 files 对应的规则
+                path = loader.find_module(module_name).path
+                if path_ignorer(Ignore_Scope.FILES, False, os.path.islink(path), path):
+                    continue
+            # 加载模块
             module = loader.find_module(module_name).load_module(module_name)
+            # 选择遍历过程中第一次找到的 Registry 实例
             if temp is None:
                 for name, obj in inspect.getmembers(module):
                     if getattr(obj, "name", None) == Registry.name and getattr(obj, "uid", None) == self.uid:
                         temp = obj
                         break
+
         if temp is not None:
             self.database = temp.database
 

kevin_toolbox/computer_science/algorithm/statistician/__init__.py

@@ -1,2 +1,3 @@
+from .accumulator_base import Accumulator_Base
 from .exponential_moving_average import Exponential_Moving_Average
 from .average_accumulator import Average_Accumulator

kevin_toolbox/computer_science/algorithm/statistician/accumulator_base.py

@@ -0,0 +1,146 @@
+from kevin_toolbox.computer_science.algorithm.statistician import init_var
+import kevin_toolbox.nested_dict_list as ndl
+
+
+class Accumulator_Base(object):
+    """
+        累积型统计器的抽象基类
+
+        包含以下变量：
+            self.var            <torch.tensor / np.ndarray / int / float> 用于保存累积值
+                                    使用 statistician._init_var() 函数进行初始化。
+                                    有三种初始化累积值（指定输入数据的格式）方式：
+                                        1. （在初始化实例时）显式指定数据的形状和所在设备等。
+                                            data_format:        <dict of paras>
+                                                    其中需要包含以下参数：
+                                                        type_:              <str>
+                                                                                "numpy":        np.ndarray
+                                                                                "torch":        torch.tensor
+                                                        shape:              <list of integers>
+                                                        device:             <torch.device>
+                                                        dtype:              <torch.dtype>
+                                        2. （在初始化实例时）根据输入的数据，来推断出形状、设备等。
+                                            like:               <torch.tensor / np.ndarray / int / float>
+                                        3. 不在初始化实例时指定 data_format 和 like，此时将等到第一次调用 add()/add_sequence()
+                                            时再根据输入来自动推断。
+                                            要实现该方式，需要在 add() 中添加:
+                                                if self.var is None:
+                                                    self.var = self._init_var(like=var)
+                                        以上三种方式，默认选用最后一种。
+                                        如果三种方式同时被指定，则优先级与对应方式在上面的排名相同。
+            self.state          <dict> 用于保存状态的字典
+                                    其中包含以下字段：
+                                        "total_nums":     <int> 用于统计一共调用了多少次 self.add() 方法去进行累积
+            self.paras          <dict> 用于保存构建实例时的各个参数
+
+        包含以下接口：
+            add()               (*)添加单个数据
+            add_sequence()      (*)添加一系列数据
+            get()               (*)获取累积值
+            clear()             情况已有数据（self.var）和状态（self.state）
+            state_dict()        返回当前实例的状态（返回一个包含 self.var 和 self.state 的字典）
+            load_state_dict()   通过接受 state_dict 来更新当前实例的状态
+
+        有可能需要另外实现or覆写的函数：
+            上面带有 (*)的接口
+            _init_state() 方法
+            _init_var() 方法
+    """
+
+    def __init__(self, **kwargs):
+        """
+            至少包含以下参数：
+                data_format:            指定数据格式（对应方式1）
+                like:                   指定数据格式（对应方式2）
+        """
+        # 默认参数
+        paras = {
+            # 指定输入数据的形状、设备
+            "data_format": None,
+            "like": None,
+        }
+
+        # 获取参数
+        paras.update(kwargs)
+
+        # 校验参数
+        #
+        self.paras = paras
+        self.var = self._init_var(like=paras["like"], data_format=paras["data_format"])
+        self.state = self._init_state()
+
+    def add_sequence(self, var_ls, **kwargs):
+        # for var in var_ls:
+        #     self.add(var)
+        raise NotImplementedError
+
+    def add(self, var, **kwargs):
+        """
+            添加单个数据
+
+            参数:
+                var:                数据
+        """
+        # if self.var is None:
+        #     self.var = self._init_var(like=var)
+        # # 累积
+        # self.state["total_nums"] += 1
+        # # 对 self.var 做处理（需要具体实现）
+        raise NotImplementedError
+
+    def get(self, **kwargs):
+        """
+            获取当前累加的平均值
+                当未有累积时，返回 None
+        """
+        # if len(self) == 0:
+        #     return None
+        # # 对 self.var 做处理并返回（需要具体实现）
+        raise NotImplementedError
+
+    @staticmethod
+    def _init_state():
+        """
+            初始化状态
+        """
+        return dict(
+            total_nums=0,
+        )
+
+    @staticmethod
+    def _init_var(like=None, data_format=None):
+        if like is not None:
+            var = init_var.by_like(var=like)
+        elif data_format is not None:
+            var = init_var.by_data_format(**kwargs)
+        else:
+            var = None
+        return var
+
+    def clear(self):
+        self.var = self._init_var(like=self.var)
+        self.state = self._init_state()
+
+    def __len__(self):
+        return self.state["total_nums"]
+
+    # ---------------------- 用于保存和加载状态 ---------------------- #
+
+    def load_state_dict(self, state_dict):
+        """
+            加载状态
+        """
+        self.clear()
+        self.state.update(state_dict.get("state", dict()))
+        if state_dict.get("var", None) is not None:
+            if self.var is None:
+                self.var = state_dict["var"]
+            else:
+                self.var *= 0
+                self.var += state_dict["var"]
+
+    def state_dict(self):
+        """
+            获取状态
+        """
+        return ndl.copy_(var={"state": self.state, "var": self.var}, b_deepcopy=True, b_keep_internal_references=True)

kevin_toolbox/computer_science/algorithm/statistician/average_accumulator.py

@@ -1,10 +1,7 @@
-import copy
-import torch
-import numpy as np
-from kevin_toolbox.computer_science.algorithm.statistician._init_var import _init_var
+from kevin_toolbox.computer_science.algorithm.statistician import Accumulator_Base
 
 
-class Average_Accumulator:
+class Average_Accumulator(Accumulator_Base):
     """
         用于计算平均值的累积器
     """
@@ -30,30 +27,13 @@ class Average_Accumulator:
                         以上三种方式，默认选用最后一种。
                         如果三种方式同时被指定，则优先级与对应方式在上面的排名相同。
         """
+        super(Average_Accumulator, self).__init__(**kwargs)
 
-        # 默认参数
-        paras = {
-            # 指定输入数据的形状、设备
-            "data_format": None,
-            "like": None,
-        }
-
-        # 获取参数
-        paras.update(kwargs)
-
-        # 校验参数
-        #
-        self.paras = paras
-        self.var = _init_var(like=paras["like"], data_format=paras["data_format"])
-        self.state = dict(
-            total_nums=0,
-        )
-
-    def add_sequence(self, var_ls):
+    def add_sequence(self, var_ls, **kwargs):
         for var in var_ls:
             self.add(var)
 
-    def add(self, var):
+    def add(self, var, **kwargs):
         """
             添加单个数据
 
@@ -61,12 +41,12 @@ class Average_Accumulator:
                 var:                数据
         """
         if self.var is None:
-            self.var = _init_var(like=var)
+            self.var = self._init_var(like=var)
         # 累积
         self.var += var
         self.state["total_nums"] += 1
 
-    def get(self):
+    def get(self, **kwargs):
         """
             获取当前累加的平均值
                 当未有累积时，返回 None
@@ -75,17 +55,10 @@ class Average_Accumulator:
             return None
         return self.var / len(self)
 
-    def clear(self):
-        self.var = _init_var(like=self.var)
-        self.state = dict(
-            total_nums=0,
-        )
-
-    def __len__(self):
-        return self.state["total_nums"]
-
 
 if __name__ == '__main__':
+    import torch
+
     seq = list(torch.tensor(range(1, 10)))
     avg = Average_Accumulator()
     for i, v in enumerate(seq):

kevin_toolbox/computer_science/algorithm/statistician/exponential_moving_average.py

@@ -1,10 +1,7 @@
-import copy
-import torch
-import numpy as np
-from kevin_toolbox.computer_science.algorithm.statistician._init_var import _init_var
+from kevin_toolbox.computer_science.algorithm.statistician import Accumulator_Base
 
 
-class Exponential_Moving_Average:
+class Exponential_Moving_Average(Accumulator_Base):
     """
         滑动平均器
             支持为每个输入数据配置不同的权重
@@ -59,12 +56,7 @@ class Exponential_Moving_Average:
         # 校验参数
         assert isinstance(paras["keep_ratio"], (int, float,)) and 0 <= paras["keep_ratio"] <= 1
         #
-        self.paras = paras
-        self.var = _init_var(like=paras["like"], data_format=paras["data_format"])
-        self.state = dict(
-            total_nums=0,
-            bias_fix=1,
-        )
+        super(Exponential_Moving_Average, self).__init__(**paras)
 
     def add_sequence(self, var_ls, weight_ls=None):
         if weight_ls is not None:
@@ -87,7 +79,7 @@ class Exponential_Moving_Average:
                                         默认为 1
         """
         if self.var is None:
-            self.var = _init_var(like=var)
+            self.var = self._init_var(like=var)
         new_ratio = (1 - self.paras["keep_ratio"]) * weight
         keep_ratio = (1 - new_ratio)
         # 累积
@@ -113,18 +105,18 @@ class Exponential_Moving_Average:
         else:
             return self.var
 
-    def clear(self):
-        self.var = _init_var(like=self.var)
-        self.state = dict(
+    @staticmethod
+    def _init_state():
+        return dict(
             total_nums=0,
             bias_fix=1,
         )
 
-    def __len__(self):
-        return self.state["total_nums"]
-
 
 if __name__ == '__main__':
+    import torch
+    import numpy as np
+
     seq = list(torch.tensor(range(1, 10)))
     wls = np.asarray([0.1] * 5 + [0.9] + [0.1] * 4) * 0.1
     ema = Exponential_Moving_Average(keep_ratio=0.9, bias_correction=True)

kevin_toolbox/computer_science/algorithm/statistician/init_var/__init__.py

@@ -0,0 +1,2 @@
+from .init_by_like import init_by_like as by_like
+from .init_by_data_format import init_by_data_format as by_data_format

kevin_toolbox/computer_science/algorithm/statistician/init_var/init_by_data_format.py

@@ -0,0 +1,24 @@
+import torch
+import numpy as np
+
+
+def init_by_data_format(type_, shape, **kwargs):
+    """
+        构建一个与输入 var 具有相同类型、形状、设备的 0 数组
+
+        参数：
+            type_:              <str>
+                                    "numpy":        np.ndarray
+                                    "torch":        torch.tensor
+                                    "number":       float
+            shape:              <list of integers>
+            device:             <torch.device>
+            dtype:              <torch.dtype / np.dtype>
+    """
+    if type_ == "torch":
+        res = torch.zeros(size=shape, **kwargs)
+    elif type_ == "numpy":
+        res = np.zeros(shape=shape, **kwargs)
+    else:
+        res = 0.0
+    return res

kevin_toolbox/computer_science/algorithm/statistician/init_var/init_by_like.py

@@ -0,0 +1,20 @@
+import torch
+import numpy as np
+
+
+def init_by_like(var):
+    """
+        构建一个与输入 var 具有相同类型、形状、设备的 0 数组
+
+        参数：
+            var:                <torch.tensor / np.ndarray / int / float>
+    """
+    if torch.is_tensor(var):
+        res = torch.zeros_like(var)
+    elif isinstance(var, (np.ndarray,)):
+        res = np.zeros_like(var)
+    elif isinstance(var, (int, float, np.number,)):
+        res = 0.0
+    else:
+        raise ValueError("paras 'like' should be np.ndarray, torch.tensor or int/float")
+    return res

kevin_toolbox/data_flow/file/json_/read_json.py

@@ -19,7 +19,7 @@ def read_json(file_path, converters=None, b_use_suggested_converter=False):
                                             默认为 False。
                     注意：当 converters 非 None，此参数失效，以 converters 中的具体设置为准
     """
-    assert os.path.isfile(file_path)
+    assert os.path.isfile(file_path), f'file {file_path} not found'
     if converters is None and b_use_suggested_converter:
         converters = [unescape_tuple, unescape_non_str_dict_key]
 

kevin_toolbox/data_flow/file/markdown/generate_table.py

@@ -1,21 +1,106 @@
-def generate_table(content_s, ordered_keys=None, orientation="vertical"):
-    ordered_keys = content_s.keys() if ordered_keys is None else ordered_keys
+from kevin_toolbox.math.utils import spilt_integer_most_evenly
+
+
+def generate_table(content_s, orientation="vertical", chunk_nums=None, chunk_size=None, b_allow_misaligned_values=False,
+                   f_gen_order_of_values=None):
+    """
+        生成表格
+
+        参数：
+            content_s:              <dict> 内容
+                                        支持两种输入模式：
+                                            1.简易模式：
+                                                content_s = {<title>: <list of value>, ...}
+                                                此时键作为标题，值作为标题下的一系列值。
+                                                由于字典的无序性，此时标题的顺序是不能保证的，若要额外指定顺序，请使用下面的 完整模式。
+                                            2. 完整模式:
+                                                content_s = {<index>: {"title": <title>,"values":<list of value>}, ...}
+                                                此时将取第 <index> 个 "title" 的值来作为第 <index> 个标题的值。values 同理。
+                                                该模式允许缺省某些 <index>，此时这些 <index> 对应的行/列将全部置空。
+            orientation:            <str> 表格的方向
+                                        支持以下值：
+                                            "vertical" / "v":       纵向排列，亦即标题在第一行
+                                            "horizontal" / "h":     横向排列，亦即标题在第一列
+            chunk_nums:             <int> 将表格平均分割为多少份进行并列显示。
+            chunk_size:             <int> 将表格按照最大长度进行分割，然后并列显示。
+                注意：以上两个参数只能设置一个，同时设置时将报错
+            b_allow_misaligned_values   <boolean> 允许不对齐的 values
+                                        默认为 False，此时当不同标题下的 values 的长度不相等时，将会直接报错。
+                                        当设置为 True 时，对于短于最大长度的 values 将直接补充 ""。
+            f_gen_order_of_values:  <callable> 生成values排序顺序的函数
+                                        该函数需要接受一个形如 {<title>: <value>, ...} 的 <dict>，并返回一个用于排序的 int/float/tuple
+    """
+    # 检验参数
+    assert chunk_nums is None or 1 <= chunk_nums
+    assert chunk_size is None or 1 <= chunk_size
     assert orientation in ["vertical", "horizontal", "h", "v"]
-    min_row_nums = min([len(i) for i in content_s.values()])
-    for k in ordered_keys:
-        assert len(content_s[k]) == min_row_nums, \
-            f'number of rows ({len(content_s[k])}) in column {k} exceeds ' \
-            f'the minimum number ({min_row_nums}) of rows in content'
 
+    # 将简易模式转换为完整模式
+    if len(content_s.values()) > 0 and not isinstance(list(content_s.values())[0], (dict,)):
+        content_s = {i: {"title": k, "values": v} for i, (k, v) in enumerate(content_s.items())}
+    # 对齐 values
+    len_ls = [len(v["values"]) for v in content_s.values()]
+    max_length = max(len_ls)
+    if min(len_ls) != max_length:
+        assert b_allow_misaligned_values, \
+            f'The lengths of the values under each title are not aligned. ' \
+            f'The maximum length is {max_length}, but each length is {len_ls}'
+        for v in content_s.values():
+            v["values"].extend([""] * (max_length - len(v["values"])))
+    # 对值进行排序
+    if callable(f_gen_order_of_values):
+        idx_ls = list(range(max_length))
+        idx_ls.sort(key=lambda x: f_gen_order_of_values({v["title"]: v["values"][x] for v in content_s.values()}))
+        for v in content_s.values():
+            v["values"] = [v["values"][i] for i in idx_ls]
+    # 补充缺省的 title
+    for i in range(max(content_s.keys()) + 1):
+        if i not in content_s:
+            content_s[i] = {"title": "", "values": [""] * max_length}
+    # 按照 chunk_nums 或者 chunk_size 对表格进行分割
+    if chunk_nums is not None or chunk_size is not None:
+        if chunk_nums is not None:
+            split_len_ls = spilt_integer_most_evenly(x=max_length, group_nums=chunk_nums)
+        else:
+            split_len_ls = [chunk_size] * (max_length // chunk_size)
+            if max_length % chunk_size != 0:
+                split_len_ls += [max_length % chunk_size]
+        max_length = max(split_len_ls)
+        temp = dict()
+        beg = 0
+        for i, new_length in enumerate(split_len_ls):
+            end = beg + new_length
+            temp.update({k + i * len(content_s): {"title": v["title"],
+                                                  "values": v["values"][beg:end] + [""] * (max_length - new_length)} for
+                         k, v in content_s.items()})
+            beg = end
+        content_s = temp
+    # 构建表格
+    return _show_table(content_s=content_s, orientation=orientation)
+
+
+def _show_table(content_s, orientation="vertical"):
+    """
+        生成表格
+
+        参数：
+            content_s:              <dict> 内容
+                                        content_s = {<index>: {"title": <title>,"values":<list of value>}, ...}
+                                        此时将取第 <index> 个 "title" 的值来作为第 <index> 个标题的值。values 同理。
+            orientation:            <str> 表格的方向
+                                        支持以下值：
+                                            "vertical" / "v":       纵向排列，亦即标题在第一行
+                                            "horizontal" / "h":     横向排列，亦即标题在第一列
+    """
     table = ""
     if orientation in ["vertical", "v"]:
-        table += "| " + " | ".join([f'{i}' for i in ordered_keys]) + " |\n"
-        table += "| " + " | ".join(["---"] * len(ordered_keys)) + " |\n"
-        for row in zip(*[content_s[k] for k in ordered_keys]):
+        table += "| " + " | ".join([f'{content_s[i]["title"]}' for i in range(len(content_s))]) + " |\n"
+        table += "| " + " | ".join(["---"] * len(content_s)) + " |\n"
+        for row in zip(*[content_s[i]["values"] for i in range(len(content_s))]):
             table += "| " + " | ".join([f'{i}' for i in row]) + " |\n"
     else:
-        for i, k in enumerate(ordered_keys):
-            row = [f'{k}'] + [f'{i}' for i in content_s[k]]
+        for i in range(len(content_s)):
+            row = [f'{content_s[i]["title"]}'] + [f'{i}' for i in content_s[i]["values"]]
             table += "| " + " | ".join(row) + " |\n"
             if i == 0:
                 table += "| " + " | ".join(["---"] * len(row)) + " |\n"
@@ -23,4 +108,23 @@ def generate_table(content_s, ordered_keys=None, orientation="vertical"):
 
 
 if __name__ == '__main__':
-    print(generate_table(content_s=dict(a=[1, 2, 3], b=[4, 5, 6]), orientation="h"))
+    content_s = {0: dict(title="a", values=[1, 2, 3]), 2: dict(title="b", values=[4, 5, 6])}
+    doc = generate_table(content_s=content_s, orientation="h")
+    print(doc)
+
+    # from collections import OrderedDict
+    #
+    # content_s = OrderedDict({
+    #     "y/n": [True] * 5 + [False] * 5,
+    #     "a": list(range(10)),
+    #     "b": [chr(i) for i in range(50, 60, 2)]
+    # })
+    # doc = generate_table(content_s=content_s, orientation="v", chunk_size=4, b_allow_misaligned_values=True,
+    #                      f_gen_order_of_values=lambda x: (-int(x["y/n"] is False), -(x["a"] % 3)))
+    # print(doc)
+    # import os
+    #
+    # with open(os.path.join(
+    #         "/home/SENSETIME/xukaiming/Desktop/my_repos/python_projects/kevin_toolbox/kevin_toolbox/data_flow/file/markdown/test/test_data/for_generate_table",
+    #         f"data_5.md"), "w") as f:
+    #     f.write(doc)

kevin_toolbox/nested_dict_list/copy_.py

@@ -1,5 +1,5 @@
 import copy
-import kevin_toolbox.nested_dict_list as ndl
+from kevin_toolbox.nested_dict_list import traverse
 import torch
 
 
@@ -121,9 +121,9 @@ def _copy_structure(var, b_keep_internal_references):
         else:
             return value.copy()
 
-    return ndl.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]
+    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]
 
 
 def _copy_nodes(var, b_keep_internal_references):
@@ -147,9 +147,9 @@ def _copy_nodes(var, b_keep_internal_references):
         else:
             return copy_item(value)
 
-    return ndl.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]
+    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]
 
 
 if __name__ == '__main__':

kevin_toolbox/nested_dict_list/serializer/__init__.py

@@ -1,2 +1,3 @@
 from .write import write
 from .read import read
+from .enum_variable import Strictness_Level

kevin_toolbox/nested_dict_list/serializer/enum_variable.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class Strictness_Level(Enum):
+    """
+        对于正确性与完整性的要求的严格程度
+    """
+    COMPLETE = "high"  # 所有节点均有一个或者多个匹配上的 backend，且第一个匹配上的 backend 就成功写入。
+    COMPATIBLE = "normal"  # 所有节点均有一个或者多个匹配上的 backend，但是首先匹配到的 backend 写入出错，使用其后再次匹配到的其他 backend 能够成功写入
+    # （这种情况更多应归咎于 backend 的 writable() 方法无法拒绝所有错误输入或者 backend 本身没有按照预期工作。一般而言这对最终写入内容的正确不会有太大影响。）
+    # 这个等级是默认等级
+    IGNORE_FAILURE = "low"  # 匹配不完整，或者某些节点尝试过所有匹配到的 backend 之后仍然无法写入