kevin-toolbox-dev 1.3.5__tar.gz → 1.3.6__tar.gz

kevin-toolbox-dev-1.3.6/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.3.6
+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.6 （2024-07-03）【new feature】
+  - patches
+    - for_os
+      - 【new feature】add find_files_in_dir()，找出目录下带有给定后缀的所有文件的生成器。
+    - for_os.path
+      - 【new feature】add find_illegal_chars()，找出给定的文件名/路径中出现了哪些非法符号。
+      - 【new feature】add replace_illegal_chars()，将给定的文件名/路径中的非法符号替换为合法形式。
+    - for_matplotlib
+      - 【new feature】add module common_charts，新增模块——常用图表，该模块下包含以下函数：
+        - plot_bars()，绘制柱状图
+        - plot_scatters()，绘制散点图
+        - plot_lines()，绘制折线图
+        - plot_distribution()，绘制分布图
+        - plot_scatters_matrix()，绘制散点图矩阵（常用于多变量关系分析）
+        - plot_confusion_matrix()，绘制混淆矩阵（常用于混淆矩阵、相关性矩阵、特征图可视化）
+    - 添加了测试用例。
+  - data_flow.file
+    - markdown
+      - 【new feature】add save_images_in_ndl()，将ndl结构叶节点下的图片对象保存到 plot_dir 中，并替换为该图片的markdown链接。
+        - 便于对表格中的图片或者列表中的图片进行保存和替换。
+      - 【new feature】add find_tables()，用于从文本中找出markdown格式的表格，并以二维数组的列表形式返回。
+      - 【new feature】add parse_table()，将二维数组形式的表格（比如find_tables()的返回列表的元素），解析成指定的格式。
+    - kevin_notation
+      - 【bug fix】fix bug in Kevin_Notation_Writer，增加检验写入的列的元素数量是否一致，不一致时进行报错。
+      - 【bug fix】fix bug in write()，避免对输入参数 metadata 中的内容进行意料之外的改动。
+  - nested_dict_list
+    - add para b_allow_override to serializer.write to allow overwriting，增加参数用于允许强制覆盖已有文件。
+  - computer_science.algorithm
+    - pareto_front
+      - 【new feature】add Optimum_Picker，帕累托最优值选取器。
+        - 记录并更新帕累托最优值
+        - 同时支持监控以下行为，并触发设定的执行器，详见参数 trigger_for_new 和 trigger_for_out。
+                              - 新加值是一个新的帕累托最优值
+                              - 抛弃一个不再是最优的旧的最优值
+    - statistician
+      - 【new feature】add Accumulator_for_Ndl，适用于 ndl 结构的统计器。
+      - 【bug fix】fix bug in Accumulator_Base._init_var()
+      - 【new feature】modify Average_Accumulator，在 add() 中新增了 weight 参数用于计算带权重的平均值
+      - modify Exponential_Moving_Average，add_sequence() 不再支持 weight_ls 参数，让该接口与其他类更加一致。
+    - 添加了测试用例。
+
+

kevin-toolbox-dev-1.3.6/README.md

@@ -0,0 +1,69 @@
+# 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.6 （2024-07-03）【new feature】
+  - patches
+    - for_os
+      - 【new feature】add find_files_in_dir()，找出目录下带有给定后缀的所有文件的生成器。
+    - for_os.path
+      - 【new feature】add find_illegal_chars()，找出给定的文件名/路径中出现了哪些非法符号。
+      - 【new feature】add replace_illegal_chars()，将给定的文件名/路径中的非法符号替换为合法形式。
+    - for_matplotlib
+      - 【new feature】add module common_charts，新增模块——常用图表，该模块下包含以下函数：
+        - plot_bars()，绘制柱状图
+        - plot_scatters()，绘制散点图
+        - plot_lines()，绘制折线图
+        - plot_distribution()，绘制分布图
+        - plot_scatters_matrix()，绘制散点图矩阵（常用于多变量关系分析）
+        - plot_confusion_matrix()，绘制混淆矩阵（常用于混淆矩阵、相关性矩阵、特征图可视化）
+    - 添加了测试用例。
+  - data_flow.file
+    - markdown
+      - 【new feature】add save_images_in_ndl()，将ndl结构叶节点下的图片对象保存到 plot_dir 中，并替换为该图片的markdown链接。
+        - 便于对表格中的图片或者列表中的图片进行保存和替换。
+      - 【new feature】add find_tables()，用于从文本中找出markdown格式的表格，并以二维数组的列表形式返回。
+      - 【new feature】add parse_table()，将二维数组形式的表格（比如find_tables()的返回列表的元素），解析成指定的格式。
+    - kevin_notation
+      - 【bug fix】fix bug in Kevin_Notation_Writer，增加检验写入的列的元素数量是否一致，不一致时进行报错。
+      - 【bug fix】fix bug in write()，避免对输入参数 metadata 中的内容进行意料之外的改动。
+  - nested_dict_list
+    - add para b_allow_override to serializer.write to allow overwriting，增加参数用于允许强制覆盖已有文件。
+  - computer_science.algorithm
+    - pareto_front
+      - 【new feature】add Optimum_Picker，帕累托最优值选取器。
+        - 记录并更新帕累托最优值
+        - 同时支持监控以下行为，并触发设定的执行器，详见参数 trigger_for_new 和 trigger_for_out。
+                              - 新加值是一个新的帕累托最优值
+                              - 抛弃一个不再是最优的旧的最优值
+    - statistician
+      - 【new feature】add Accumulator_for_Ndl，适用于 ndl 结构的统计器。
+      - 【bug fix】fix bug in Accumulator_Base._init_var()
+      - 【new feature】modify Average_Accumulator，在 add() 中新增了 weight 参数用于计算带权重的平均值
+      - modify Exponential_Moving_Average，add_sequence() 不再支持 weight_ls 参数，让该接口与其他类更加一致。
+    - 添加了测试用例。

{kevin-toolbox-dev-1.3.5 → kevin-toolbox-dev-1.3.6}/kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.3.5"
+__version__ = "1.3.6"
 
 
 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 1731518184 --verbose 0'
+    f'--expiration_timestamp 1735563213 --verbose 0'
 )

{kevin-toolbox-dev-1.3.5 → kevin-toolbox-dev-1.3.6}/kevin_toolbox/computer_science/algorithm/pareto_front/__init__.py

@@ -1 +1,2 @@
 from .get_pareto_points_idx import get_pareto_points_idx, Direction
+from .optimum_picker import Optimum_Picker

kevin-toolbox-dev-1.3.6/kevin_toolbox/computer_science/algorithm/pareto_front/optimum_picker.py

@@ -0,0 +1,218 @@
+from kevin_toolbox.computer_science.data_structure import Executor
+from kevin_toolbox.computer_science.algorithm.pareto_front import get_pareto_points_idx, Direction
+import kevin_toolbox.nested_dict_list as ndl
+import numpy as np
+
+
+class Optimum_Picker:
+    """
+        记录并更新帕累托最优值
+            同时支持监控以下行为：
+                - 新加值是一个新的帕累托最优值
+                - 抛弃一个不再是最优的旧的最优值
+            并触发设定的执行器，详见参数 trigger_for_new 和 trigger_for_out
+    """
+
+    def __init__(self, **kwargs):
+        """
+            参数：
+                directions:             <list of Direction> 比较的方向
+                trigger_for_new:        <Executor> 触发器
+                                            当 add() 新添加的监控值是一个新的帕累托最优时，执行该触发器
+                                            在执行前，将自动往触发器的 kwargs 中添加 {"metrics": <metrics>, "step": <step>, ...} 等信息
+                trigger_for_out:        <Executor> 触发器
+                                            当 add() 时候需要抛弃一些不再是的帕累托最优的历史值时，执行该触发器
+                                            在执行前，将自动往触发器的 kwargs 中添加 {"metrics": <metrics>, "step": <step>, ...} 等信息
+                warmup_steps:           <int> 在经过多少次 add() 之后，再开始比较监控值
+                                            默认为 0
+                pick_per_steps:         <int> 每经过多少次 add()，就比较一次监控值
+                                            默认为 1
+        """
+        # 默认参数
+        paras = {
+            "directions": None,
+            "trigger_for_new": None,
+            "trigger_for_out": None,
+            "warmup_steps": 0,
+            "pick_per_steps": 1,
+        }
+
+        # 获取参数
+        paras.update(kwargs)
+
+        # 校验参数
+        assert paras["warmup_steps"] >= 0 and paras["pick_per_steps"] >= 1
+        paras["directions"] = [Direction(i) for i in paras["directions"]]
+        for k in ["trigger_for_out", "trigger_for_new"]:
+            assert isinstance(paras[k], (type(None), Executor))
+
+        self.paras = paras
+        self._state = self._init_state()
+
+    def _init_state(self):
+        return dict(
+            optimal_ls=list(),  # [{"metrics":metrics, "record":record, "step":step}, ...]
+            step=0,
+            b_empty_cache=True,
+            last_optimal_nums=0
+        )
+
+    def add(self, metrics, b_force_clear_cache=False, **kwargs):
+        """
+            添加指标
+
+            参数：
+                metrics:                    指标
+                b_force_clear_cache:        <boolean> 是否强制清空缓存
+                                                默认为 False，此时将根据设定的 warmup_steps 和 pick_per_steps 来决定何时清空一次缓存
+                **kwargs:                   用户自定义记录
+                                                将被添加到 record 中
+        """
+        assert metrics is not None
+        metrics = np.asarray(metrics).reshape(1, -1)
+        assert metrics.shape[-1] == len(self.paras["directions"])
+
+        optimal_ls, step = self._state["optimal_ls"], self._state["step"]
+        new_record = dict(metrics=metrics, step=step)
+        new_record.update(kwargs)
+        #
+        optimal_ls.append(new_record)
+        self._state["step"] += 1
+
+        # warmup & cache
+        if not b_force_clear_cache and (step < self.paras["warmup_steps"] or
+                                        (step - self.paras["warmup_steps"]) % self.paras["pick_per_steps"] != 0):
+            self._state["b_empty_cache"] = False
+            return
+
+        # 找出新的帕累托最优值
+        points = np.concatenate([i["metrics"] for i in optimal_ls])
+        idx_ls = get_pareto_points_idx(points=points, directions=self.paras["directions"])
+        idx_ls.sort()
+        # 进行触发操作
+        if self.paras["trigger_for_new"] is not None:
+            for i in filter(lambda i: i >= self._state["last_optimal_nums"], idx_ls):
+                self.paras["trigger_for_new"].run(**optimal_ls[i])
+        #
+        if self.paras["trigger_for_out"] is not None:
+            for i in set(range(self._state["last_optimal_nums"])).difference(set(idx_ls)):
+                self.paras["trigger_for_out"].run(**optimal_ls[i])
+
+        # 更新
+        self._state["optimal_ls"] = [optimal_ls[i] for i in idx_ls]
+        self._state["b_empty_cache"] = True
+        self._state["last_optimal_nums"] = len(idx_ls)
+
+    def get(self, b_force_clear_cache=False):
+        """
+            获取当前最优值记录
+
+            参数：
+                b_force_clear_cache:        <boolean> 是否强制清空缓存
+
+            返回：
+                record_ls:          <list of dict> 最优记录
+                b_empty_cache:      <boolean> 缓存是否清空，亦即 record_ls 是否是真正的最优记录
+                                        当 pick_per_steps > 1 时，将有部分记录留存在缓存中，没有进行比较，此时的最优记录并不是完整的也不是最新的
+        """
+        if b_force_clear_cache and not self._state["b_empty_cache"] and len(self._state["optimal_ls"]) > 0:
+            # 需要清空缓存，就把最后一次缓存的记录拿出来，重新使用 b_force_clear_cache=False 去 add 一次
+            record = self._state["optimal_ls"].pop(-1)
+            metrics, step = record.pop("metrics"), record.pop("step")
+            self._state["step"] -= 1
+            assert self._state["step"] == step
+            self.add(metrics=metrics, b_force_clear_cache=True, **record)
+
+        return self._state["optimal_ls"][:], self._state["b_empty_cache"] or b_force_clear_cache
+
+    def clear(self):
+        self._state = self._init_state()
+
+    def __len__(self):
+        return self._state["step"]
+
+    # ---------------------- 用于保存和加载状态 ---------------------- #
+    def load_state_dict(self, state_dict):
+        """
+            加载状态
+        """
+        self.clear()
+        self._state.update(state_dict)
+
+    def state_dict(self):
+        """
+            获取状态
+        """
+        return ndl.copy_(var=self._state, b_deepcopy=True, b_keep_internal_references=True)
+
+
+if __name__ == '__main__':
+    """
+        模拟场景
+            在训练模型时，要求比较 val_acc_1（maximize） 和 val_error_2（minimize），
+            要求保存其帕累托最优时的模型。
+    """
+    import torch
+    import matplotlib.pyplot as plt
+
+    # 一个打乱的圆的采样点序列
+    metrics = torch.tensor([(-4.045084971874739, -2.9389262614623632),
+                            (-3.1871199487434474, -3.852566213878947),
+                            (-2.1288964578253635, 4.524135262330097),
+                            (-4.648882429441257, -1.8406227634233896),
+                            (-4.648882429441256, 1.8406227634233907),
+                            (-0.936906572928623, 4.911436253643443),
+                            (0.31395259764656414, -4.990133642141358),
+                            (-4.960573506572389, 0.6266661678215226),
+                            (-3.1871199487434487, 3.852566213878946),
+                            (4.381533400219316, -2.4087683705085805),
+                            (0.31395259764656763, 4.990133642141358),
+                            (2.6791339748949827, 4.221639627510076),
+                            (4.8429158056431545, -1.2434494358242767),
+                            (1.5450849718747361, -4.755282581475768),
+                            (4.842915805643155, 1.243449435824274),
+                            (3.644843137107056, -3.422735529643445),
+                            (5.0, 0.0),
+                            (-2.128896457825361, -4.524135262330099),
+                            (2.6791339748949836, -4.221639627510075),
+                            (-4.9605735065723895, -0.6266661678215214),
+                            (3.644843137107058, 3.422735529643443),
+                            (4.381533400219318, 2.4087683705085765),
+                            (-0.9369065729286231, -4.911436253643443),
+                            (-4.045084971874736, 2.9389262614623664),
+                            (1.5450849718747373, 4.755282581475767)])
+    # 右下角的点是帕累托最优
+    best_idx_ls = [6, 9, 12, 13, 15, 16, 18]
+
+    # 将x和y坐标分别存储在两个列表中
+    x_coords = metrics[:, 0].numpy().tolist()
+    y_coords = metrics[:, 1].numpy().tolist()
+    # 按顺序绘制点
+    plt.plot(x_coords, y_coords, marker='o')
+    # 添加顺序标签
+    for i, txt in enumerate(range(len(metrics))):
+        plt.annotate(txt, (x_coords[i], y_coords[i]), textcoords="offset points", xytext=(0, 5), ha='center')
+    plt.show()
+    import os
+    from kevin_toolbox.data_flow.file import json_
+    from kevin_toolbox.patches.for_os import remove
+
+    temp_dir = os.path.join(os.path.dirname(__file__), "temp")
+    remove(temp_dir, ignore_errors=True)
+
+    opt_picker = Optimum_Picker(
+        warmup_steps=9, pick_per_steps=5,
+        trigger_for_new=Executor(
+            func=lambda metrics, step: json_.write(metrics.tolist(), os.path.join(temp_dir, f'{step}.json'))),
+        trigger_for_out=Executor(func=lambda step, **kwargs: remove(os.path.join(temp_dir, f'{step}.json'))),
+        directions=["maximize", "minimize"]
+    )
+    for s, v in enumerate(metrics):
+        opt_picker.add(metrics=v)
+        print()
+        print(s, v)
+        print(opt_picker.get()[1])
+        print([i["step"] for i in opt_picker.get()[0]])
+
+    for i in best_idx_ls:
+        assert os.path.isfile(os.path.join(temp_dir, f'{i}.json'))

{kevin-toolbox-dev-1.3.5 → kevin-toolbox-dev-1.3.6}/kevin_toolbox/computer_science/algorithm/statistician/__init__.py

@@ -1,3 +1,4 @@
 from .accumulator_base import Accumulator_Base
 from .exponential_moving_average import Exponential_Moving_Average
 from .average_accumulator import Average_Accumulator
+from .accumulator_for_ndl import Accumulator_for_Ndl

{kevin-toolbox-dev-1.3.5 → kevin-toolbox-dev-1.3.6}/kevin_toolbox/computer_science/algorithm/statistician/accumulator_base.py

@@ -71,7 +71,7 @@ class Accumulator_Base(object):
 
     def add_sequence(self, var_ls, **kwargs):
         # for var in var_ls:
-        #     self.add(var)
+        #     self.add(var, **kwargs)
         raise NotImplementedError
 
     def add(self, var, **kwargs):
@@ -112,7 +112,7 @@ class Accumulator_Base(object):
         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)
+            var = init_var.by_data_format(**data_format)
         else:
             var = None
         return var

kevin-toolbox-dev-1.3.6/kevin_toolbox/computer_science/algorithm/statistician/accumulator_for_ndl.py

@@ -0,0 +1,69 @@
+import torch
+import kevin_toolbox.nested_dict_list as ndl
+from kevin_toolbox.computer_science.algorithm.statistician import Accumulator_Base
+
+
+class Accumulator_for_Ndl:
+    """
+        适用于 ndl 结构的统计器
+    """
+
+    def __init__(self, accumulator_builder):
+        """
+            参数：
+                accumulator_builder:        ndl叶节点统计器的构造函数
+        """
+        assert callable(accumulator_builder) or isinstance(accumulator_builder, Accumulator_Base)
+        self.accumulator_builder = accumulator_builder
+
+        self.var = None
+
+    def add(self, var, **kwargs):
+        if self.var is None and isinstance(var, (dict, list)):
+            self.var = type(var)()
+        for name, value in ndl.get_nodes(var=var, level=-1, b_strict=True):
+            accumulator = ndl.get_value(var=self.var, name=name, default=None)
+            if accumulator is None:
+                accumulator = self.accumulator_builder()
+                self.var = ndl.set_value(var=self.var, name=name, value=accumulator, b_force=True)
+            value = value.detach().cpu().numpy() if torch.is_tensor(value) else value
+            accumulator.add(value, **kwargs)
+
+    def add_sequence(self, var_ls, **kwargs):
+        for var in var_ls:
+            self.add(var, **kwargs)
+
+    def get(self, **kwargs):
+        return ndl.traverse(
+            var=ndl.copy_(var=self.var, b_deepcopy=False),
+            match_cond=lambda _, __, v: not isinstance(v, (dict, list)) and hasattr(v, "get"), action_mode="replace",
+            converter=lambda _, v: v.get(**kwargs)
+        )
+
+
+if __name__ == '__main__':
+    from kevin_toolbox.data_flow.file import markdown
+    import numpy as np
+    from kevin_toolbox.computer_science.algorithm.statistician import Average_Accumulator
+
+    worker = Accumulator_for_Ndl(accumulator_builder=Average_Accumulator)
+
+    worker.add({
+        1: 2.1,
+        "233": torch.ones(10),
+        "543": [
+            np.array([1, 2, 3]),
+            np.array([4, 5, 6]),
+        ]
+    }, weight=0.8)
+
+    worker.add({
+        1: 3.1,
+        "233": torch.zeros(10),
+        "543": [
+            np.array([0, 2, 3]),
+            np.array([0, 5, 6]),
+        ]
+    }, weight=1.4)
+
+    print(markdown.generate_list(var=worker.get()))

{kevin-toolbox-dev-1.3.5 → kevin-toolbox-dev-1.3.6}/kevin_toolbox/computer_science/algorithm/statistician/average_accumulator.py

@@ -31,20 +31,22 @@ class Average_Accumulator(Accumulator_Base):
 
     def add_sequence(self, var_ls, **kwargs):
         for var in var_ls:
-            self.add(var)
+            self.add(var, **kwargs)
 
-    def add(self, var, **kwargs):
+    def add(self, var, weight=1, **kwargs):
         """
             添加单个数据
 
             参数:
                 var:                数据
+                weight:             权重
         """
         if self.var is None:
             self.var = self._init_var(like=var)
         # 累积
-        self.var += var
+        self.var = self.var + var * weight
         self.state["total_nums"] += 1
+        self.state["total_weights"] += weight
 
     def get(self, **kwargs):
         """
@@ -53,7 +55,17 @@ class Average_Accumulator(Accumulator_Base):
         """
         if len(self) == 0:
             return None
-        return self.var / len(self)
+        return self.var / self.state["total_weights"]
+
+    @staticmethod
+    def _init_state():
+        """
+            初始化状态
+        """
+        return dict(
+            total_nums=0,
+            total_weights=0,
+        )
 
 
 if __name__ == '__main__':

{kevin-toolbox-dev-1.3.5 → kevin-toolbox-dev-1.3.6}/kevin_toolbox/computer_science/algorithm/statistician/exponential_moving_average.py

@@ -58,18 +58,11 @@ class Exponential_Moving_Average(Accumulator_Base):
         #
         super(Exponential_Moving_Average, self).__init__(**paras)
 
-    def add_sequence(self, var_ls, weight_ls=None):
-        if weight_ls is not None:
-            if isinstance(weight_ls, (int, float,)):
-                weight_ls = [weight_ls] * len(var_ls)
-            assert len(weight_ls) == len(var_ls)
-            for var, weight in enumerate(var_ls, weight_ls):
-                self.add(var, weight)
-        else:
-            for var in var_ls:
-                self.add(var)
+    def add_sequence(self, var_ls, **kwargs):
+        for var in var_ls:
+            self.add(var, **kwargs)
 
-    def add(self, var, weight=1):
+    def add(self, var, weight=1, **kwargs):
         """
             添加单个数据
 
@@ -88,7 +81,7 @@ class Exponential_Moving_Average(Accumulator_Base):
         self.state["total_nums"] += 1
         self.state["bias_fix"] *= keep_ratio
 
-    def get(self, bias_correction=None):
+    def get(self, bias_correction=None, **kwargs):
         """
             获取当前累加值
                 当未初始化时，返回 None

{kevin-toolbox-dev-1.3.5 → kevin-toolbox-dev-1.3.6}/kevin_toolbox/data_flow/file/kevin_notation/kevin_notation_writer.py

@@ -313,6 +313,9 @@ class Kevin_Notation_Writer:
             try:
                 # 解释为多行
                 assert paras.get("b_single_line", None) in (None, False)
+                temp = [len(paras["column_dict"][k]) for k in self.metadata["column_name"]]
+                if temp:
+                    assert max(temp) == min(temp), f"Error: the length of each column is not equal!"
                 row_ls = list(zip(*[paras["column_dict"][k] for k in self.metadata["column_name"]]))
             except:
                 # 解释为单行

kevin-toolbox-dev-1.3.6/kevin_toolbox/data_flow/file/kevin_notation/test/test_kevin_notation_debug.py

@@ -0,0 +1,27 @@
+import pytest
+from kevin_toolbox.patches.for_test import check_consistency
+
+import os
+import numpy as np
+
+from kevin_toolbox.data_flow.file import kevin_notation
+from kevin_toolbox.data_flow.file.kevin_notation.test.test_data.data_all import metadata_ls, content_ls, file_path_ls
+
+
+@pytest.mark.parametrize("expected_metadata, expected_content, file_path",
+                         zip(metadata_ls, content_ls, file_path_ls))
+def test_write(expected_metadata, expected_content, file_path):
+    print("test write()")
+
+    """
+    当写入的列的元素不一致时，是否能正常报错
+    """
+
+    # 新建
+    file_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "test_data/temp", os.path.basename(file_path))
+
+    # 字典方式写入
+    if len(expected_content) > 1:
+        with pytest.raises(AssertionError):
+            list(expected_content.values())[0].clear()
+            kevin_notation.write(metadata=expected_metadata, content=expected_content, file_path=file_path)

{kevin-toolbox-dev-1.3.5 → kevin-toolbox-dev-1.3.6}/kevin_toolbox/data_flow/file/kevin_notation/write.py

@@ -5,6 +5,9 @@ def write(metadata, content, file_path):
     """
         写入整个文件的快捷接口
     """
+    if "column_num" in metadata:
+        metadata=metadata.copy()
+        metadata.pop("column_num")
     with kevin_notation.Writer(file_path=file_path, mode="w", sep=metadata.get("sep", "\t")) as writer:
         writer.write_metadata(metadata=metadata)
         if isinstance(content, (dict,)):

{kevin-toolbox-dev-1.3.5 → kevin-toolbox-dev-1.3.6}/kevin_toolbox/data_flow/file/markdown/__init__.py

@@ -1,3 +1,6 @@
 from .generate_link import generate_link
 from .generate_list import generate_list
 from .generate_table import generate_table
+from .parse_table import parse_table
+from .find_tables import find_tables
+from .save_images_in_ndl import save_images_in_ndl