kevin-toolbox-dev 1.4.12__tar.gz → 1.4.13__tar.gz

kevin-toolbox-dev-1.4.13/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.4.13
+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.13 （2025-07-21）【bug fix】【new feature】
+  - data_flow.file.markdown
+    - modify find_tables()，完善读取表格函数，支持更多的表格格式，包括以梅花线作为标题栏分割线，表格最左侧和最右侧分割线省略等情况。
+  - nested_dict_list.serializer
+    - modify read()，支持在读取时通过参数 b_keep_identical_relations 对 record.json 中的同名参数进行覆盖。
+  - computer_science.algorithm
+    - redirector
+      - 【bug fix】fix bug in _randomly_idx_redirector() for Redirectable_Sequence_Fetcher，改正了 rng.randint(low, high) 中参数 high 的设置。
+    - pareto_front
+      - modify get_pareto_points_idx()，支持参数 directions 只输入单个值来表示所有方向都使用该值。
+    - sampler
+      - 【new feature】add Recent_Sampler，最近采样器：始终保留最近加入的 capacity 个样本。
+  - patches.for_matplotlib
+    - common_charts.utils
+      - modify .save_plot()，将原来在 output_path 为 None 时使用 plt.show() 展示图像的行为改为返回 np.array 形式的图像，并支持通过参数 b_show_plot 来单独控制是否展示图像。
+      - 【new feature】add log_scaling()，用于处理坐标系变换。
+    - common_charts
+      - 【new feature】add plot_3d()，绘制3D图，支持：散点图、三角剖分曲面及其平滑版本。
+      - 【new feature】add plot_contour()，绘制等高线图。
+      - 【new feature】add plot_mean_std_lines()，绘制均值和标准差折线图及其区域填充。
+      - 【new feature】add plot_2d_matrix()，计算并绘制混淆矩阵。
+
+
+

kevin-toolbox-dev-1.4.13/README.md

@@ -0,0 +1,51 @@
+# 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.13 （2025-07-21）【bug fix】【new feature】
+  - data_flow.file.markdown
+    - modify find_tables()，完善读取表格函数，支持更多的表格格式，包括以梅花线作为标题栏分割线，表格最左侧和最右侧分割线省略等情况。
+  - nested_dict_list.serializer
+    - modify read()，支持在读取时通过参数 b_keep_identical_relations 对 record.json 中的同名参数进行覆盖。
+  - computer_science.algorithm
+    - redirector
+      - 【bug fix】fix bug in _randomly_idx_redirector() for Redirectable_Sequence_Fetcher，改正了 rng.randint(low, high) 中参数 high 的设置。
+    - pareto_front
+      - modify get_pareto_points_idx()，支持参数 directions 只输入单个值来表示所有方向都使用该值。
+    - sampler
+      - 【new feature】add Recent_Sampler，最近采样器：始终保留最近加入的 capacity 个样本。
+  - patches.for_matplotlib
+    - common_charts.utils
+      - modify .save_plot()，将原来在 output_path 为 None 时使用 plt.show() 展示图像的行为改为返回 np.array 形式的图像，并支持通过参数 b_show_plot 来单独控制是否展示图像。
+      - 【new feature】add log_scaling()，用于处理坐标系变换。
+    - common_charts
+      - 【new feature】add plot_3d()，绘制3D图，支持：散点图、三角剖分曲面及其平滑版本。
+      - 【new feature】add plot_contour()，绘制等高线图。
+      - 【new feature】add plot_mean_std_lines()，绘制均值和标准差折线图及其区域填充。
+      - 【new feature】add plot_2d_matrix()，计算并绘制混淆矩阵。
+

{kevin-toolbox-dev-1.4.12 → kevin-toolbox-dev-1.4.13}/kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.4.12"
+__version__ = "1.4.13"
 
 
 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 1763992975 --verbose 0'
+    f'--expiration_timestamp 1768647143 --verbose 0'
 )

{kevin-toolbox-dev-1.4.12 → kevin-toolbox-dev-1.4.13}/kevin_toolbox/computer_science/algorithm/pareto_front/get_pareto_points_idx.py

@@ -31,6 +31,8 @@ def get_pareto_points_idx(points, directions=None):
     """
     points = np.asarray(points)
     assert points.ndim == 2 and len(points) > 0
+    if directions is not None and not isinstance(directions, (list, tuple,)):
+        directions = [directions] * points.shape[-1]
     assert directions is None or isinstance(directions, (list, tuple,)) and len(directions) == points.shape[-1]
 
     # 计算排序的权重

{kevin-toolbox-dev-1.4.12 → kevin-toolbox-dev-1.4.13}/kevin_toolbox/computer_science/algorithm/redirector/redirectable_sequence_fetcher.py

@@ -6,11 +6,11 @@ from kevin_toolbox.computer_science.algorithm.cache_manager import Cache_Manager
 
 def _randomly_idx_redirector(idx, seq_len, attempts, rng, *args):
     if idx == 0:
-        return rng.randint(1, seq_len - 1)
+        return rng.randint(1, seq_len)
     elif idx == seq_len - 1:
-        return rng.randint(0, seq_len - 2)
+        return rng.randint(0, seq_len - 1)
     else:
-        return rng.choice([rng.randint(0, idx - 1), rng.randint(idx + 1, seq_len - 1)], size=1,
+        return rng.choice([rng.randint(0, idx), rng.randint(idx + 1, seq_len)], size=1,
                           p=[idx / (seq_len - 1), (seq_len - idx - 1) / (seq_len - 1)])[0]
 
 

{kevin-toolbox-dev-1.4.12 → kevin-toolbox-dev-1.4.13}/kevin_toolbox/computer_science/algorithm/sampler/__init__.py

@@ -1 +1,2 @@
 from .reservoir_sampler import Reservoir_Sampler
+from .recent_sampler import Recent_Sampler

kevin-toolbox-dev-1.4.13/kevin_toolbox/computer_science/algorithm/sampler/recent_sampler.py

@@ -0,0 +1,128 @@
+class Recent_Sampler:
+    """
+        最近采样器：始终保留最近加入的 capacity 个样本
+    """
+
+    def __init__(self, **kwargs):
+        """
+            参数：
+                capacity:                       <int> 缓冲区或窗口的容量
+        """
+        # 默认参数
+        paras = {
+            "capacity": 1,
+        }
+
+        # 获取并更新参数
+        paras.update(kwargs)
+
+        # 校验 capacity
+        assert paras["capacity"] >= 1
+
+        self.paras = paras
+        self.cache = []  # 用列表来保存最近的样本
+        self.state = self._init_state()  # state 只记录 total_nums
+
+    @staticmethod
+    def _init_state():
+        """
+            初始化状态，仅记录已添加的总样本数
+        """
+        return dict(
+            total_nums=0,
+        )
+
+    def add(self, item, **kwargs):
+        """
+            添加单个数据 item 到采样器中。
+            - 更新 total_nums 计数
+            - 将 item 追加到 cache 末尾
+            - 如果超出 capacity，则删除最旧的一个（即列表开头的元素）
+        """
+        self.state["total_nums"] += 1
+        self.cache.append(item)
+        if len(self.cache) > self.paras["capacity"]:
+            self.cache.pop(0)
+
+    def add_sequence(self, item_ls, **kwargs):
+        """
+            批量添加：对列表中每个元素多次调用 add
+        """
+        for item in item_ls:
+            self.add(item, **kwargs)
+
+    def get(self, **kwargs):
+        """
+            返回当前缓冲区中的数据列表（浅拷贝）。
+        """
+        return self.cache.copy()
+
+    def clear(self):
+        """
+            清空已有数据和状态，重置采样器。
+        """
+        self.cache.clear()
+        self.state = self._init_state()
+
+    def __len__(self):
+        """
+            返回已添加的总样本数（state["total_nums"]），
+            而不是当前缓冲区长度
+        """
+        return self.state["total_nums"]
+
+    # ---------------------- 用于保存和加载状态 ---------------------- #
+
+    def load_state_dict(self, state_dict):
+        """
+            加载状态
+            - 清空当前缓冲区和 state
+            - 恢复 state["total_nums"]
+            - 恢复 cache 列表内容
+            - 恢复 rng 状态
+        """
+        self.clear()
+        self.state.update(state_dict["state"])
+        self.cache.extend(state_dict["cache"])
+
+    def state_dict(self, b_deepcopy=True):
+        """
+            获取当前状态，包含：
+            - state: {"total_nums": ...}
+            - cache: 当前缓冲区列表
+        """
+        temp = {
+            "state": self.state,
+            "cache": self.cache
+        }
+        if b_deepcopy:
+            import kevin_toolbox.nested_dict_list as ndl
+            temp = ndl.copy_(var=temp, b_deepcopy=True, b_keep_internal_references=True)
+        return temp
+
+
+# 测试示例
+if __name__ == "__main__":
+    # 创建一个容量为 5 的 Recent_Sampler
+    sampler = Recent_Sampler(capacity=5)
+
+    # 逐个添加 1 到 10 的数字
+    for i in range(1, 11):
+        sampler.add(i)
+        print(f"添加 {i} 后缓冲区: {sampler.get()}")
+
+    # 到这里，缓冲区中应该只保留最近加入的 5 个样本：6,7,8,9,10
+    print("最终缓冲区:", sampler.get())  # 预期输出: [6,7,8,9,10]
+    print("总共添加个数:", len(sampler))  # 预期输出: 10
+
+    # 保存当前状态
+    state = sampler.state_dict()
+    print("状态字典:", state)
+
+    # 清空后再恢复状态
+    sampler.clear()
+    print("清空后缓冲区:", sampler.get())  # 预期输出: []
+
+    sampler.load_state_dict(state)
+    print("恢复后缓冲区:", sampler.get())  # 预期输出: [6,7,8,9,10]
+    print("恢复后总共添加个数:", len(sampler))  # 预期输出: 10

{kevin-toolbox-dev-1.4.12 → kevin-toolbox-dev-1.4.13}/kevin_toolbox/computer_science/algorithm/sampler/reservoir_sampler.py

@@ -61,13 +61,13 @@ class Reservoir_Sampler:
 
     def get(self, **kwargs):
         """
-        返回当前水库中的数据列表（拷贝）。
+            返回当前水库中的数据列表（浅拷贝）。
         """
         return self.reservoir.copy()
 
     def clear(self):
         """
-        清空已有数据和状态，重置采样器。
+            清空已有数据和状态，重置采样器。
         """
         self.reservoir.clear()
         self.state = self._init_state()

{kevin-toolbox-dev-1.4.12 → kevin-toolbox-dev-1.4.13}/kevin_toolbox/data_flow/file/markdown/table/find_tables.py

@@ -52,23 +52,49 @@ def find_tables(text, b_compact_format=True):
         return table_ls, part_slices_ls, table_idx_ls
 
 
+# def _find_table(text):
+#     # 正则表达式匹配Markdown表格
+#     table_pattern = re.compile(r'\|([^\n]+)\|', re.DOTALL)
+#     table_matches = table_pattern.findall(text)
+#     if len(table_matches) < 2:
+#         # 因为一个合法的 markdown 表格需要含有表头的分隔线，所以行数至少应该为 2
+#         return None
+#
+#     # 去除表头的分隔线
+#     table_matches.pop(1)
+#     #
+#     tables = []  # 每个元素为一行
+#     for match in table_matches:
+#         # 分割每一行
+#         tables.append([i.strip() for i in match.split('|', -1)])
+#
+#     return {"matrix": tables, "orientation": None}
+
 def _find_table(text):
-    # 正则表达式匹配Markdown表格
-    table_pattern = re.compile(r'\|([^\n]+)\|', re.DOTALL)
-    table_matches = table_pattern.findall(text)
-    if len(table_matches) < 2:
+    # 按行分割文本
+    lines = text.splitlines()
+    table_rows = []
+    for line in lines:
+        # 移除行首尾空白
+        stripped_line = line.strip()
+        if not stripped_line:
+            continue  # 跳过空行
+        # 移除行首尾的可选竖线（如果存在）
+        if stripped_line.startswith('|'):
+            stripped_line = stripped_line[1:]
+        if stripped_line.endswith('|'):
+            stripped_line = stripped_line[:-1]
+        # 分割单元格并去除每个单元格的空白
+        row_cells = [cell.strip() for cell in stripped_line.split('|')]
+        table_rows.append(row_cells)
+
+    if len(table_rows) < 2:
         # 因为一个合法的 markdown 表格需要含有表头的分隔线，所以行数至少应该为 2
         return None
-
     # 去除表头的分隔线
-    table_matches.pop(1)
-    #
-    tables = []  # 每个元素为一行
-    for match in table_matches:
-        # 分割每一行
-        tables.append([i.strip() for i in match.split('|', -1)])
+    table_rows.pop(1)
 
-    return {"matrix": tables, "orientation": None}
+    return {"matrix": table_rows, "orientation": None}
 
 
 if __name__ == '__main__':

kevin-toolbox-dev-1.4.13/kevin_toolbox/developing/file_management/__init__.py

@@ -0,0 +1 @@
+from .file_feature_extractor import File_Feature_Extractor

kevin-toolbox-dev-1.4.13/kevin_toolbox/developing/file_management/file_feature_extractor.py

@@ -0,0 +1,263 @@
+import os
+import time
+import json
+import hashlib
+from enum import Enum
+from kevin_toolbox.patches import for_os
+from kevin_toolbox.data_flow.file import json_
+
+
+class F_Type(Enum):
+    file = 0
+    symlink = 1
+    dir = 2
+    unknown = -1
+
+
+class File_Feature_Extractor:
+    """
+        文件特征提取器类，用于扫描指定目录下所有文件（包括文件夹和符号链接），提取：
+            - 文件元数据
+            - 浅哈希值（仅支持对文件使用）
+            - 完整哈希值等特征（仅支持对文件使用）
+        并支持缓存、更新和持久化。
+
+        参数：
+            input_dir:                      <str> 根目录路径
+            metadata_cfg:                   <dict> 提取元信息的方式。
+                                                接受一个形如 {"attribute": ["size", ...], "include": ["file", ...], ...} 的字典，
+                                                其中 "attribute" 字段下指定需要添加的元信息，目前支持：
+                                                    - size 文件大小
+                                                    - created_time、modified_time、accessed_time 时间
+                                                    - mode 权限
+                                                    - is_symlink、is_dir、is_file 种类
+                                                    - is_symlink_valid 链接是否有效
+                                                而 "include" 字段用于指定要遍历的目标类型。
+                                                默认 "attribute" 和 "include" 均包含以上全部支持的选项。
+                                                当设置为 None 时，表示不提取元信息。
+            hash_cfg:                       <dict> 提取浅哈希的方式。
+                                                接受形如 {"algorithm": ["md5", ...], "read_size": [<int>, None, ...], ...} 的字典
+                                                其中 "algorithm" 表示使用的哈希算法类型，支持：
+                                                    - 'md5', 'sha1', 'sha256'
+                                                默认 "algorithm" 包含 "md5"。
+                                                而 "read_size" 表示读取文件内容的最大前 N 个字节的内容来计算哈希值，支持：
+                                                    - <int> 表示需要读取前 N 个字节
+                                                    - None 表示读取整个文件
+                                                默认 "read_size" 中的值为 [1024, None, ...]
+            b_read_dst_of_symlink:          <boolean> 是否读取链接指向的目标文件。
+                                                默认为 False。
+            include:                        <list> 指定要遍历的目标类型
+                                                当上面的 xxx_cfg 参数中没有额外指定 "include" 字段时，将以该参数作为该字段的默认参数。
+                                                当给定值为 str 时，支持：
+                                                    - "symlink"、"dir"、"file"
+                                                当给定值为 dict 时，支持：
+                                                    - {"filter_type": "suffix", "option_ls": [...]} 根据后缀进行选择。
+                                                    - {"filter_type": "small_than", "size": <int>, "b_include_equal": <boolean>} 根据文件大小（单位为字节）选择。
+                                                当给定值为函数时，函数应该形如：
+                                                    - func(file_path) ==> <boolean>     当函数返回值为 True 时，表示匹配成功。
+                                                另有一个特殊值为 None，表示匹配所有
+            exclude:                        <list> 指定要排除的目标类型
+                                                其设置参考 include。
+                                                默认为 None，表示不排除任何
+            walk_paras:                     <dict> 调用 for_os.walk() 对目录进行遍历时的参数
+                                                利用该参数可以实现更高级的指定遍历顺序、排除内容的操作
+
+        结果的形式：
+            {
+                <folder_A>:{
+                    <folder_B>:{
+                        (<base_name>, <type>):
+                            {
+                                "metadata": {"size": ..., ...},
+                                "hash": {
+                                    <size>: {"md5": ...., "sha": ...}
+                                },
+                                "dst_of_symlink": {"metadata": ...., "hash": ...}
+                            }
+                    }
+                }
+            }
+            其中 type 有 "symlink"、"dir"、"file" None 几种取值
+
+        方法：
+            scan():                 扫描所有文件，提取特征并写入缓存
+            update():               增量更新，只有当文件修改时间变化时才重新提取
+            save_cache(file_path):   将当前缓存保存为 JSON 文件
+            load_cache(file_path):   从 JSON 文件中加载缓存
+    """
+
+    def __init__(self, **kwargs):
+        # 默认参数
+        paras = {
+            "input_dir": None,
+            "metadata_cfg": {"attribute": {"size", "created_time", "modified_time", "accessed_time",
+                                           "mode", "is_symlink", "is_dir", "is_file", "is_symlink_valid"}, },
+            "hash_cfg": {"algorithm": {"md5", }, "read_size": {1024, None}, },
+            "b_read_dst_of_symlink": False,
+            "include": None,
+            "exclude": None,
+            "walk_paras": dict(topdown=True, onerror=None, followlinks=False, ignore_s=None)
+        }
+
+        # 获取参数
+        paras.update(kwargs)
+
+        # 校验参数
+        if not paras["input_dir"] or not os.path.isdir(paras["input_dir"]):
+            raise ValueError(f'invalid input_dir {paras["input_dir"]}')
+        #
+        for k in ["metadata_cfg", "hash_cfg"]:
+            paras[k].setdefault('include', paras['include'])
+            paras[k].setdefault('exclude', paras['exclude'])
+        self.cache = {}
+        self.paras = paras
+
+    @staticmethod
+    def _matches(path, rule_ls):
+        """
+            判断路径是否符合规则
+        """
+        path = os.path.realpath(path)
+        stat = os.lstat(path)
+        for rule in rule_ls:
+            # 类型字符串匹配
+            if isinstance(rule, str):
+                if rule == 'file' and os.path.isfile(path): return True
+                if rule == 'dir' and os.path.isdir(path): return True
+                if rule == 'symlink' and os.path.islink(path): return True
+                return False
+            # 后缀过滤
+            if isinstance(rule, dict):
+                ft = rule.get('filter_type')
+                if ft == 'suffix':
+                    return any(path.endswith(suf) for suf in rule.get('option_ls', []))
+                elif ft == 'small_than':
+                    size = stat.st_size
+                    limit = rule.get('size', 0)
+                    eq = rule.get('b_include_equal', False)
+                    return size < limit or (eq and size == limit)
+            # 函数
+            if callable(rule):
+                return rule(path)
+            return False
+        return False
+
+    @staticmethod
+    def _get_metadata(path, attribute):
+        """
+            获取文件元信息
+        """
+        path = os.path.realpath(path)
+        stat = os.lstat(path)
+        res_s = dict()
+        for attr in attribute:
+            if attr == 'size': res_s['size'] = stat.st_size
+            if attr == 'created_time': res_s['created_time'] = stat.st_ctime
+            if attr == 'modified_time': res_s['modified_time'] = stat.st_mtime
+            if attr == 'accessed_time': res_s['accessed_time'] = stat.st_atime
+            if attr == 'mode': res_s['mode'] = stat.st_mode
+            if attr == 'is_symlink': res_s['is_symlink'] = os.path.islink(path)
+            if attr == 'is_dir': res_s['is_dir'] = os.path.isdir(path)
+            if attr == 'is_file': res_s['is_file'] = os.path.isfile(path)
+            if attr == 'is_symlink_valid':
+                res_s['is_symlink_valid'] = os.path.islink(path) and os.path.exists(os.readlink(path))
+        return res_s
+
+    @staticmethod
+    def _get_hash(path, read_size_ls, algorithm_ls):
+        """
+            对文件进行哈希，read_size=None 表示完整哈希，否则浅哈希
+        """
+        res_s = dict()
+        for size in read_size_ls:
+            for algo in algorithm_ls:
+                h = hashlib.new(algo)
+                with open(path, 'rb') as f:
+                    if size is not None:
+                        data = f.read(size)
+                        h.update(data)
+                    else:
+                        for chunk in iter(lambda: f.read(8192), b''):
+                            h.update(chunk)
+                res_s[size] = res_s.get(size, dict())
+                res_s[size][algo] = h.hexdigest()
+        return res_s
+
+    def extract_feature(self, path, metadata_cfg=None, hash_cfg=None):
+        metadata_cfg = metadata_cfg or self.paras['metadata_cfg']
+        hash_cfg = hash_cfg or self.paras['hash_cfg']
+        path = os.path.realpath(path)
+        res_s = dict()
+        base_ = os.path.basename(path)
+        if os.path.islink(path):
+            f_type = F_Type.symlink
+        elif os.path.isfile(path):
+            f_type = F_Type.file
+        elif os.path.isdir(path):
+            f_type = F_Type.dir
+        else:
+            f_type = F_Type.unknown
+        try:
+            if metadata_cfg is not None:
+                res_s["metadata"] = self._get_metadata(path, attribute=metadata_cfg['attribute'])
+            if hash_cfg is not None and f_type == F_Type.file:
+                res_s["hash"] = self._get_hash(path, read_size_ls=hash_cfg['read_size'],
+                                               algorithm_ls=hash_cfg['algorithm'])
+            if os.path.islink(path) and self.paras['b_read_dst_of_symlink']:
+                dst = os.readlink(path)
+                res_s['dst_of_symlink'] = self.extract_feature(dst)
+        except Exception as e:
+            res_s = {'error': str(e)}
+        return base_, f_type.value, res_s
+
+    def scan_path(self, path, metadata_cfg=None, hash_cfg=None):
+        """
+            扫描路径，提取特征并写入缓存
+        """
+        path = os.path.realpath(path)
+        rel = os.path.relpath(path, self.paras["input_dir"])
+        parts = rel.split(os.sep)
+        node = self.cache
+        for p in parts[:-1]:
+            node = node.setdefault(p, {})
+        base_, f_type, res_s = self.extract_feature(path=path, metadata_cfg=metadata_cfg, hash_cfg=hash_cfg)
+        node[(base_, f_type)] = res_s
+
+    def scan_recursively(self, path=None, metadata_cfg=None, hash_cfg=None):
+        """
+            递归扫描目录，提取特征并写入缓存
+        """
+        path = path or self.paras["input_dir"]
+        for root, dirs, files in for_os.walk(top=path, **self.paras["walk_paras"]):
+            for name in files + dirs:
+                full_path = os.path.join(root, name)
+                if self.paras["include"] is not None:
+                    if not self._matches(full_path, rule_ls=self.paras["include"]):
+                        continue
+                if self.paras["exclude"] is not None:
+                    if self._matches(full_path, rule_ls=self.paras["exclude"]):
+                        continue
+                self.scan_path(full_path, metadata_cfg=metadata_cfg, hash_cfg=hash_cfg)
+
+    def update(self):
+        """
+        增量更新，重新扫描修改过的文件
+        """
+        # 简化：重新全量扫描覆盖旧缓存，可按需优化
+        self.cache.clear()
+        self.scan_recursively()
+
+    def save_cache(self, file_path):
+        json_.write(content=self.cache, file_path=file_path, b_use_suggested_converter=True)
+
+    def load_cache(self, file_path):
+        self.cache = json_.read(file_path=file_path, b_use_suggested_converter=True)
+
+
+if __name__ == '__main__':
+    from kevin_toolbox.data_flow.file import markdown
+    file_feature_extractor = File_Feature_Extractor(
+        input_dir=os.path.join(os.path.dirname(__file__), "test/test_data")
+    )
+    file_feature_extractor.scan_recursively()
+    print(markdown.generate_list(file_feature_extractor.cache))

{kevin-toolbox-dev-1.4.12 → kevin-toolbox-dev-1.4.13}/kevin_toolbox/nested_dict_list/serializer/read.py

@@ -12,6 +12,7 @@ def read(input_path, **kwargs):
 
         参数：
             input_path:             <path> 文件夹或者 .tar 文件，具体结构参考 write()
+            b_keep_identical_relations: <boolean> 覆盖 record.json 中记录的同名参数，该参数的作用详见 write() 中的介绍。
     """
     assert os.path.exists(input_path)
 
@@ -42,7 +43,7 @@ def _read_unpacked_ndl(input_path, **kwargs):
 
     # 读取被处理的节点
     processed_nodes = []
-    if record_s:
+    if "processed" in record_s:
         for name, value in ndl.get_nodes(var=record_s["processed"], level=-1, b_strict=True):
             if value:
                 processed_nodes.append(name)
@@ -68,6 +69,8 @@ def _read_unpacked_ndl(input_path, **kwargs):
             ndl.set_value(var=var, name=name, value=bk.read(**value))
 
     #
+    if "b_keep_identical_relations" in kwargs:
+        record_s["b_keep_identical_relations"] = kwargs["b_keep_identical_relations"]
     if record_s.get("b_keep_identical_relations", False):
         from kevin_toolbox.nested_dict_list import value_parser
         var = value_parser.replace_identical_with_reference(var=var, flag="same", b_reverse=True)

{kevin-toolbox-dev-1.4.12 → kevin-toolbox-dev-1.4.13}/kevin_toolbox/patches/for_matplotlib/common_charts/__init__.py

@@ -52,3 +52,5 @@ from .plot_2d_matrix import plot_2d_matrix
 from .plot_contour import plot_contour
 from .plot_3d import plot_3d
 from .plot_from_record import plot_from_record
+# from .plot_raincloud import plot_raincloud
+from .plot_mean_std_lines import plot_mean_std_lines