kevin-toolbox-dev 1.3.4__py3-none-any.whl → 1.3.6__py3-none-any.whl

kevin_toolbox/patches/for_matplotlib/common_charts/plot_scatters.py

@@ -0,0 +1,53 @@
+import os
+import matplotlib.pyplot as plt
+from kevin_toolbox.patches.for_matplotlib import generate_color_list
+from kevin_toolbox.patches.for_os.path import replace_illegal_chars
+
+
+def plot_scatters(data_s, title, x_name, y_name, cate_name=None, output_dir=None, **kwargs):
+    paras = {
+        "dpi": 200,
+        "scatter_size": 5
+    }
+    paras.update(kwargs)
+
+    plt.clf()
+    #
+    color_s = None
+    if cate_name is not None:
+        cates = list(set(data_s[cate_name]))
+        color_s = {i: j for i, j in zip(cates, generate_color_list(nums=len(cates)))}
+        c = [color_s[i] for i in data_s[cate_name]]
+    else:
+        c = "blue"
+    # 创建散点图
+    plt.scatter(data_s[x_name], data_s[y_name], s=paras["scatter_size"], c=c, alpha=0.8)
+    #
+    plt.xlabel(f'{x_name}')
+    plt.ylabel(f'{y_name}')
+    plt.title(f'{title}')
+    # 添加图例
+    if cate_name is not None:
+        plt.legend(handles=[
+            plt.Line2D([0], [0], marker='o', color='w', label=i, markerfacecolor=j,
+                       markersize=min(paras["scatter_size"], 5)) for i, j in color_s.items()
+        ])
+
+    if output_dir is None:
+        plt.show()
+        return None
+    else:
+        os.makedirs(output_dir, exist_ok=True)
+        output_path = os.path.join(output_dir, f'{replace_illegal_chars(title)}.png')
+        plt.savefig(output_path, dpi=paras["dpi"])
+        return output_path
+
+
+if __name__ == '__main__':
+    data_s_ = dict(
+        x=[1, 2, 3, 4, 5],
+        y=[2, 4, 6, 8, 10],
+        categories=['A', 'B', 'A', 'B', 'A']
+    )
+
+    plot_scatters(data_s=data_s_, title='test', x_name='x', y_name='y', cate_name='categories')

kevin_toolbox/patches/for_matplotlib/common_charts/plot_scatters_matrix.py

@@ -0,0 +1,54 @@
+import os
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+from kevin_toolbox.patches.for_matplotlib import generate_color_list
+from kevin_toolbox.patches.for_os.path import replace_illegal_chars
+
+
+def plot_scatters_matrix(data_s, title, x_name_ls, cate_name=None, output_dir=None, cate_color_s=None, **kwargs):
+    paras = {
+        "dpi": 200,
+        "diag_kind": "kde"  # 设置对角线图直方图/密度图 {‘hist’, ‘kde’}
+    }
+    assert cate_name in data_s and len(set(x_name_ls).difference(set(data_s.keys()))) == 0
+    if cate_color_s is None:
+        temp = set(data_s[cate_name])
+        cate_color_s = {k: v for k, v in zip(temp, generate_color_list(len(temp)))}
+    assert set(cate_color_s.keys()) == set(data_s[cate_name])
+    paras.update(kwargs)
+
+    plt.clf()
+    # 使用seaborn绘制散点图矩阵
+    sns.pairplot(
+        pd.DataFrame(data_s),
+        diag_kind=paras["diag_kind"],  # 设置对角线图直方图/密度图 {‘hist’, ‘kde’}
+        hue=cate_name,  # hue 表示根据该列的值进行分类
+        palette=cate_color_s, x_vars=x_name_ls, y_vars=x_name_ls,  # x_vars，y_vars 指定子图的排列顺序
+    )
+    #
+    plt.subplots_adjust(top=0.95)
+    plt.suptitle(f'{title}', y=0.98, x=0.47)
+    # g.fig.suptitle(f'{title}', y=1.05)
+
+    if output_dir is None:
+        plt.show()
+        return None
+    else:
+        os.makedirs(output_dir, exist_ok=True)
+        output_path = os.path.join(output_dir, f'{replace_illegal_chars(title)}.png')
+        plt.savefig(output_path, dpi=paras["dpi"])
+        return output_path
+
+
+if __name__ == '__main__':
+    data_s_ = dict(
+        x=[1, 2, 3, 4, 5],
+        y=[2, 4, 6, 8, 10],
+        z=[2, 4, 6, 8, 10],
+        categories=['A', 'B', 'A', 'B', 'A'],
+        title='test',
+    )
+
+    plot_scatters_matrix(data_s=data_s_, title='test', x_name_ls=['y', 'x', 'z'], cate_name='categories',
+                         cate_color_s={'A': 'red', 'B': 'blue'})

kevin_toolbox/patches/for_os/__init__.py

@@ -1,4 +1,7 @@
 from .remove import remove
+from .copy import copy
 from .pack import pack
 from .unpack import unpack
 from .walk import walk, Path_Ignorer, Ignore_Scope
+from .find_files_in_dir import find_files_in_dir
+from . import path

kevin_toolbox/patches/for_os/copy.py

@@ -0,0 +1,33 @@
+import os
+import shutil
+from kevin_toolbox.patches.for_os import remove
+
+
+def copy(src, dst, follow_symlinks=True, remove_dst_if_exists=False):
+    """
+        复制文件/文件夹/软连接
+
+        参数：
+            follow_symlinks:        <boolean> 是否跟随符号链接
+                                    对于 src 是软连接或者 src 指向的目录下具有软连接的情况，
+                                        当设置为 True 时，会复制所有链接指向的实际文件或目录内容。
+                                        当设置为 False 时，则仅仅软连接本身，而不是指向的内容
+                                    默认为 True
+            remove_dst_if_exists:   <boolean> 当目标存在时，是否尝试进行移除
+    """
+    assert os.path.exists(src), f'failed to copy, src not exists: {src}'
+    if remove_dst_if_exists:
+        remove(path=dst, ignore_errors=True)
+    assert not os.path.exists(dst), f'failed to copy, dst exists: {dst}'
+
+    os.makedirs(os.path.dirname(dst), exist_ok=True)
+    if os.path.isdir(src):
+        if not follow_symlinks and os.path.islink(src):
+            # 如果是符号链接，并且我们跟随符号链接，则复制链接本身
+            os.symlink(os.readlink(src), dst)
+        else:
+            # 否则，递归复制目录
+            shutil.copytree(src, dst, symlinks=not follow_symlinks)
+    else:
+        # 复制文件
+        shutil.copy2(src, dst, follow_symlinks=follow_symlinks)

kevin_toolbox/patches/for_os/find_files_in_dir.py

@@ -0,0 +1,30 @@
+import os
+from kevin_toolbox.patches.for_os import walk
+
+
+def find_files_in_dir(input_dir, suffix_ls, b_relative_path=True, b_ignore_case=True):
+    """
+        找出目录下带有给定后缀的所有文件的生成器
+            主要利用了 for_os.walk 中的过滤规则进行实现
+
+        参数：
+            suffix_ls:          <list/tuple of str> 可选的后缀
+            b_relative_path:    <bool> 是否返回相对路径
+            b_ignore_case:      <bool> 是否忽略大小写
+    """
+    suffix_ls = tuple(set(suffix_ls))
+    suffix_ls = tuple(map(lambda x: x.lower(), suffix_ls)) if b_ignore_case else suffix_ls
+    for root, dirs, files in walk(top=input_dir, topdown=True,
+                                  ignore_s=[{
+                                      "func": lambda _, b_is_symlink, path: b_is_symlink or not (
+                                              path.lower() if b_ignore_case else path).endswith(suffix_ls),
+                                      "scope": ["files", ]
+                                  }]):
+        for file in files:
+            file_path = os.path.join(root, file)
+            if b_relative_path:
+                file_path = os.path.relpath(file_path, start=input_dir)
+            yield file_path
+
+
+

kevin_toolbox/patches/for_os/path/__init__.py

@@ -0,0 +1,2 @@
+from .find_illegal_chars import find_illegal_chars
+from .replace_illegal_chars import replace_illegal_chars

kevin_toolbox/patches/for_os/path/find_illegal_chars.py

@@ -0,0 +1,47 @@
+import os
+import re
+
+ILLEGAL_CHARS = {
+    '<': '＜',
+    '>': '＞',
+    ':': '：',
+    '"': '＂',
+    '/': '／',
+    '\\': '＼',
+    '|': '｜',
+    '?': '？',
+    '*': '＊'
+}
+
+ILLEGAL_CHARS_PATTERN = re.compile(r'[<>:"/\\|?*]')
+
+
+def find_illegal_chars(file_name, b_is_path=False):
+    """
+        找出给定的文件名/路径中出现了哪些非法符号
+            所谓非法符号是指在特定系统（win/mac等）中文件名不允许出现的字符，
+            不建议在任何系统下使用带有这些符号的文件名，即使这些符号在当前系统中是合法的，
+            以免在跨系统时出现兼容性问题
+
+        参数：
+            file_name:      <str>
+            b_is_path:      <bool> 是否将file_name视为路径
+                                默认为 False
+                                当设置为 True 时，将会首先将file_name分割，再逐级从目录名中查找
+    """
+    global ILLEGAL_CHARS_PATTERN
+
+    if b_is_path:
+        temp = [i for i in file_name.split(os.sep, -1) if len(i) > 0]
+    else:
+        temp = [file_name]
+    res = []
+    for i in temp:
+        res.extend(ILLEGAL_CHARS_PATTERN.findall(i))
+    return res
+
+
+if __name__ == '__main__':
+    file_path = '//data0//b/<?>.md'
+    print(find_illegal_chars(file_name=file_path, b_is_path=True))
+    print(find_illegal_chars(file_name=file_path, b_is_path=False))

kevin_toolbox/patches/for_os/path/replace_illegal_chars.py

@@ -0,0 +1,49 @@
+import os
+import re
+
+ILLEGAL_CHARS = {
+    '<': '＜',
+    '>': '＞',
+    ':': '：',
+    '"': '＂',
+    '/': '／',
+    '\\': '＼',
+    '|': '｜',
+    '?': '？',
+    '*': '＊'
+}
+ILLEGAL_CHARS_PATTERN = re.compile('|'.join(re.escape(char) for char in ILLEGAL_CHARS.keys()))
+
+
+def replace_illegal_chars(file_name, b_is_path=False):
+    """
+        将给定的文件名/路径中的非法符号替换为合法形式
+            所谓非法符号是指在特定系统（win/mac等）中文件名不允许出现的字符，
+            不建议在任何系统下使用带有这些符号的文件名，即使这些符号在当前系统中是合法的，
+            以免在跨系统时出现兼容性问题。
+
+        参数：
+            file_name:      <str>
+            b_is_path:      <bool> 是否将file_name视为路径
+                                默认为 False
+                                当设置为 True 时，将会首先将file_name分割，再逐级处理目录名，最后合并为路径
+    """
+    if not b_is_path:
+        res = _replace_illegal_chars(var=file_name)
+    else:
+        temp = file_name.split(os.sep, -1)
+        res = os.path.join(*[_replace_illegal_chars(var=i) for i in temp if len(i) > 0])
+        if len(temp[0]) == 0:
+            res = os.sep + res
+    return res
+
+
+def _replace_illegal_chars(var):
+    global ILLEGAL_CHARS_PATTERN
+    return ILLEGAL_CHARS_PATTERN.sub(lambda m: ILLEGAL_CHARS[m.group(0)], var)
+
+
+if __name__ == '__main__':
+    file_path = 'data0//b/<?>.md'
+    print(replace_illegal_chars(file_name=file_path, b_is_path=True))
+    print(replace_illegal_chars(file_name=file_path, b_is_path=False))

kevin_toolbox/patches/for_test/check_consistency.py

@@ -7,7 +7,8 @@ import kevin_toolbox.nested_dict_list as ndl
 def check_consistency(*args, tolerance=1e-7, require_same_shape=True):
     """
         检查 args 中多个变量之间是否一致
-            变量支持python的所有内置类型，以及复杂的 nested_dict_list 结构， array 等
+            变量支持 python 的所有内置类型，以及复杂的 nested_dict_list 结构， array 等
+            对于 array，不区分 numpy 的 array，torch 的 tensor，还是 tuple of number，只要其中的值相等，即视为相同。
 
         参数：
             tolerance:          <float> 判断 <np.number/np.bool_> 之间是否一致时，的容许误差。
@@ -28,13 +29,13 @@ def check_consistency(*args, tolerance=1e-7, require_same_shape=True):
         try:
             _check_item(*names_ls, tolerance=tolerance, require_same_shape=True)
         except AssertionError as e:
-            assert False, f'inputs <nested_dict_list> has different structure\nthe nodes that differ are:\n{e}'
+            raise AssertionError(f'inputs <nested_dict_list> has different structure\nthe nodes that differ are:\n{e}')
         for its in zip(names_ls[0], *values_ls):
             try:
                 _check_item(*its[1:], tolerance=tolerance, require_same_shape=require_same_shape)
             except AssertionError as e:
-                assert False, \
-                    f'value of nodes {its[0]} in inputs <nested_dict_list> are inconsistent\nthe difference is:\n{e}'
+                raise AssertionError(
+                    f'value of nodes {its[0]} in inputs <nested_dict_list> are inconsistent\nthe difference is:\n{e}')
     # 简单结构
     else:
         _check_item(*args, tolerance=tolerance, require_same_shape=require_same_shape)
@@ -45,44 +46,111 @@ def _check_item(*args, tolerance, require_same_shape):
         检查 args 中多个 array 之间是否一致
 
         工作流程：
-            本函数会首先将输入的 args 中的所有变量转换为 np.array;
-            然后使用 issubclass() 判断转换后得到的变量属于以下哪几种基本类型：
-                - 当所有变量都属于 np.number 数值（包含int、float等）或者 np.bool_ 布尔值时，
-                    将对变量两两求差，当差值小于给定的容许误差 tolerance 时，视为一致。
-                - 当所有变量都属于 np.flexible 可变长度类型（包含string等）或者 np.object 时，
-                    将使用==进行比较，当返回值都为 True 时，视为一致。
-                - 当变量的基本类型不一致（比如同时有np.number和np.flexible）时，
-                    直接判断为不一致。
-            numpy 中基本类型之间的继承关系参见： https://numpy.org.cn/reference/arrays/scalars.html
+            1. 对于 args 都是 tuple/list 且每个 tuple/list 的长度都一致的情况，将会拆分为对应各个元素递归进行比较。
+            2. 将 args 中的 tuple 和 tensor 分别转换为 list 和 numpy。
+            3. 检查 args 中是否有 np.array 或者 tensor，若有则根据 require_same_shape 判断其形状是否一致。
+            4. 先将输入的 args 中的所有变量转换为 np.array;
+                然后使用 issubclass() 判断转换后得到的变量属于以下哪几种基本类型：
+                    - 当所有变量都属于 np.number 数值（包含int、float等）或者 np.bool_ 布尔值时，
+                        将对变量两两求差，当差值小于给定的容许误差 tolerance 时，视为一致。
+                        注意：在比较过程中，若变量中存在 np.nan 值，将会首先比较有 np.nan 值的位置是否相等，然后再比较非 np.nan 值部分。
+                            亦即在相同位置上都具有 np.nan 视为相同。
+                            比如 [np.nan, np.nan, 3] 和 [np.nan, np.nan, 3] 会视为相等，
+                            [np.nan, np.nan] 和 np.nan 在 require_same_shape=False 时会被视为相等。
+                    - 当所有变量都属于 np.flexible 可变长度类型（包含string等）或者 np.object 时，
+                        将使用==进行比较，当返回值都为 True 时，视为一致。
+                    - 当变量的基本类型不一致（比如同时有np.number和np.flexible）时，
+                        直接判断为不一致。
+                numpy 中基本类型之间的继承关系参见： https://numpy.org.cn/reference/arrays/scalars.html
 
         参数：
             tolerance:          <float> 判断 <np.number/np.bool_> 之间是否一致时，的容许误差。
             require_same_shape: <boolean> 是否强制要求变量的形状一致。
-                                    当设置为 False 时，不同形状的变量可能因为 numpy 的 broadcast 机制而在比较前自动 reshape 为相同维度，进而可能通过比较。
+                                    注意：仅在原始 args 中含有 np.array 或者 tensor 的情况会采取 broadcast，亦即此时该参数才会起效。
+                                    当设置为 False 时，不同形状的变量可能因为 broadcast 机制而在比较前自动 reshape 为相同维度，进而通过比较。
     """
-    np.warnings.filterwarnings('ignore', category=np.VisibleDeprecationWarning)
+    warnings.filterwarnings('ignore', category=np.VisibleDeprecationWarning)
     warnings.filterwarnings("ignore", category=DeprecationWarning)
 
     assert len(args) >= 2
-    assert isinstance(tolerance, (int, float,))
+    assert isinstance(tolerance, (int, float,)) and tolerance >= 0
+    raw_args = args
+
+    # 当 args 都是 tuple/list 且每个 tuple 的长度都一致时，将会拆分为对应各个元素进行比较
+    if all([isinstance(i, (tuple, list)) for i in args]) and all([len(i) == len(args[0]) for i in args[1:]]):
+        for i, it_ls in enumerate(zip(*args)):
+            try:
+                _check_item(*it_ls, tolerance=tolerance, require_same_shape=require_same_shape)
+            except AssertionError as e:
+                raise AssertionError(f'elements {i} are inconsistent\nthe difference is:\n{e}')
+        return
+
+    #
+    args = ndl.traverse(var=list(args), match_cond=lambda _, __, v: isinstance(v, (tuple,)), action_mode="replace",
+                        converter=lambda _, v: list(v), b_traverse_matched_element=True)
+    args = ndl.traverse(var=list(args), match_cond=lambda _, __, v: torch.is_tensor(v), action_mode="replace",
+                        converter=lambda _, v: v.detach().cpu().numpy(), b_traverse_matched_element=False)
+    b_has_raw_array = any([isinstance(i, np.ndarray) for i in args])
 
-    args = [v.detach().cpu() if torch.is_tensor(v) else v for v in args]
-    args = [np.asarray(v) for v in args]
+    try:
+        args = [np.asarray(v) for v in args]  # if b_has_raw_array else [np.array(v, dtype=object) for v in args]
+    except Exception as e:
+        raise RuntimeError(f'{raw_args} cannot be converted to np.array, \n'
+                           f'because {e}')
 
-    for v in args[1:]:
+    # 比较形状
+    if b_has_raw_array:
         if require_same_shape:
-            assert args[0].shape == v.shape, \
-                f"{args[0]}, {v}, different shape: {args[0].shape}, {v.shape}"
-        if issubclass(args[0].dtype.type, (np.number, np.bool_,)):
-            # 数字类型
+            # 要求形状一致
+            for v in args[1:]:
+                assert args[0].shape == v.shape, \
+                    f"{args[0]}, {v}, different shape: {args[0].shape}, {v.shape}"
+        else:
+            # 否则要求至少能够进行 broadcast
+            for v in args[1:]:
+                try:
+                    np.broadcast_arrays(args[0], v)
+                except:
+                    raise AssertionError(f'{args[0]}, {v}, failed to broadcast')
+            # 如果都是空的 array，直接视为相等
+            if all([i.size == 0 for i in args]):
+                return
+    b_allow_broadcast = b_has_raw_array and not require_same_shape
+
+    # 比较值
+    if issubclass(args[0].dtype.type, (np.number, np.bool_,)):
+        # 数字类型
+        for v in args[1:]:
             assert issubclass(v.dtype.type, (np.number, np.bool_,))
-            if args[0].size > 0:
-                assert np.max(np.abs(args[0] - v.astype(dtype=float))) < tolerance, \
-                    f"{args[0]}, {v}, deviation: {np.max(np.abs(args[0] - v))}"
-        elif issubclass(args[0].dtype.type, (np.flexible, object,)):
-            # 可变长度类型
+            v_0, v_1 = args[0].astype(dtype=float), v.astype(dtype=float)
+            v_0, v_1 = np.broadcast_arrays(v_0, v_1) if b_allow_broadcast else (v_0, v_1)
+            assert v_0.shape == v_1.shape, \
+                f'{v_0}, {v_1}, different shape: {v_0.shape}, {v_1.shape}'
+            #
+            if v_0.size > 0:
+                try:
+                    if np.any(np.isnan(v)):
+                        assert np.all(np.isnan(v_0) == np.isnan(v_1))
+                        v_0 = np.nan_to_num(v_0, nan=1e10)
+                        v_1 = np.nan_to_num(v_1, nan=1e10)
+                    assert np.max(np.abs(v_0 - v_1)) < tolerance
+                except AssertionError:
+                    raise AssertionError(f"{args[0]}, {v}, deviation: {np.max(np.abs(args[0] - v))}")
+    elif issubclass(args[0].dtype.type, (np.flexible, object,)):
+        # 可变长度类型
+        for v in args[1:]:
             assert issubclass(v.dtype.type, (np.flexible, object,))
-            for i, j in zip(args[0].reshape(-1), v.reshape(-1)):
+            v_0, v_1 = np.broadcast_arrays(args[0], v) if b_allow_broadcast else (args[0], v)
+            assert v_0.shape == v_1.shape, \
+                f'{v_0}, {v_1}, different shape: {v_0.shape}, {v_1.shape}\n' + (
+                    '' if require_same_shape else
+                    f'\tMore details: \n'
+                    f'\t\tAlthough require_same_shape=False has been setted, broadcast failed because the variable at \n'
+                    f'\t\tthis position does not contain elements of type np.array and tensor.')
+            #
+            for i, j in zip(v_0.reshape(-1), v_1.reshape(-1)):
+                if i is j:
+                    continue
                 temp = i == j
                 if isinstance(temp, (bool,)):
                     assert temp, \
@@ -90,14 +158,17 @@ def _check_item(*args, tolerance, require_same_shape):
                 else:
                     assert temp.all(), \
                         f"{args[0]}, {v}, diff: {temp}"
-        else:
-            raise ValueError
+    else:
+        raise ValueError
 
 
 if __name__ == '__main__':
     a = np.array([[1, 2, 3]])
     b = np.array([[1, 2, 3]])
     c = {'d': 3, 'c': 4}
-    check_consistency([c, a], [c, b])
 
-    check_consistency(True, True)
+    # var = ((1, 2), (4))
+    #
+    # var = ndl.traverse(var=[var], match_cond=lambda _, __, v: isinstance(v, (tuple,)), action_mode="replace",
+    #                    converter=lambda _, v: list(v), b_traverse_matched_element=True)[0]
+    # print(var)

kevin_toolbox_dev-1.3.6.dist-info/METADATA

@@ -0,0 +1,95 @@
+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
+Requires-Dist: torch (>=1.2.0)
+Requires-Dist: numpy (>=1.19.0)
+Provides-Extra: plot
+Requires-Dist: matplotlib (>=3.0) ; extra == 'plot'
+Provides-Extra: rest
+Requires-Dist: pytest (>=6.2.5) ; extra == 'rest'
+Requires-Dist: line-profiler (>=3.5) ; 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 参数，让该接口与其他类更加一致。
+    - 添加了测试用例。
+
+