kevin-toolbox-dev 1.4.7__tar.gz → 1.4.9__tar.gz

kevin-toolbox-dev-1.4.9/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.4.9
+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.9 （2025-03-27）【new feature】【bug fix】
+
+  - patches.for_numpy.linalg
+    - 【bug fix】fix bug in softmax()，修改 33 行，从减去全局最大值改为减去各个分组内部的最大值，避免全局最大值过大导致某些分组全体数值过小导致计算溢出。
+  - patches.for_matplotlib.common_charts.utils
+    - modify save_plot()，在最后增加 plt.close() 用于及时销毁已使用完的画布，避免不必要的内存占用。
+  - nested_dict_list
+    - 【new feature】modify traverse()，增加以下参数以更加精确地控制遍历时的行为：
+      - b_skip_repeated_non_leaf_node:  是否跳过重复的非叶节点。
+        - 何为重复？在内存中的id相同。
+        - 默认为 None，此时将根据 action_mode 的来决定：
+          - 对于会对节点进行修改的模式，比如 "remove" 和 "replace"，将设为 True，以避免预期外的重复转换和替换。
+          - 对于不会修改节点内容的模式，比如 "skip"，将设为 False。
+      - cond_for_repeated_leaf_to_skip：函数列表。在叶节点位置上，遇到满足其中某个条件的重复的元素时需要跳过。
+    - 同步修改内部使用了 traverse() 的 get_nodes() 和 copy_() 等函数。
+    - 新增了对应的测试用例。
+  - data_flow.file.json_
+    - 【bug fix】fix bug in write()。
+      - bug 归因：在 json_.write() 中通过使用 ndl.traverse() 来找出待转换的元素并进行转换，但是在 v1.4.8 前，该函数默认不会跳过重复（在内存中的id相同）出现的内容。由于该内容的不同引用实际上指向的是同一个，因此对这些引用的分别多次操作实际上就是对该内容进行了多次操作。
+      - bug 解决：在后续 v1.4.9 中为 ndl.traverse() 新增了 b_skip_repeated_non_leaf_node 用于控制是否需要跳过重复的引用。我们只需要在使用该函数时，令参数 b_skip_repeated_non_leaf_node=True即可。
+
+

kevin-toolbox-dev-1.4.9/README.md

@@ -0,0 +1,49 @@
+# 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.9 （2025-03-27）【new feature】【bug fix】
+
+  - patches.for_numpy.linalg
+    - 【bug fix】fix bug in softmax()，修改 33 行，从减去全局最大值改为减去各个分组内部的最大值，避免全局最大值过大导致某些分组全体数值过小导致计算溢出。
+  - patches.for_matplotlib.common_charts.utils
+    - modify save_plot()，在最后增加 plt.close() 用于及时销毁已使用完的画布，避免不必要的内存占用。
+  - nested_dict_list
+    - 【new feature】modify traverse()，增加以下参数以更加精确地控制遍历时的行为：
+      - b_skip_repeated_non_leaf_node:  是否跳过重复的非叶节点。
+        - 何为重复？在内存中的id相同。
+        - 默认为 None，此时将根据 action_mode 的来决定：
+          - 对于会对节点进行修改的模式，比如 "remove" 和 "replace"，将设为 True，以避免预期外的重复转换和替换。
+          - 对于不会修改节点内容的模式，比如 "skip"，将设为 False。
+      - cond_for_repeated_leaf_to_skip：函数列表。在叶节点位置上，遇到满足其中某个条件的重复的元素时需要跳过。
+    - 同步修改内部使用了 traverse() 的 get_nodes() 和 copy_() 等函数。
+    - 新增了对应的测试用例。
+  - data_flow.file.json_
+    - 【bug fix】fix bug in write()。
+      - bug 归因：在 json_.write() 中通过使用 ndl.traverse() 来找出待转换的元素并进行转换，但是在 v1.4.8 前，该函数默认不会跳过重复（在内存中的id相同）出现的内容。由于该内容的不同引用实际上指向的是同一个，因此对这些引用的分别多次操作实际上就是对该内容进行了多次操作。
+      - bug 解决：在后续 v1.4.9 中为 ndl.traverse() 新增了 b_skip_repeated_non_leaf_node 用于控制是否需要跳过重复的引用。我们只需要在使用该函数时，令参数 b_skip_repeated_non_leaf_node=True即可。

{kevin-toolbox-dev-1.4.7 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.4.7"
+__version__ = "1.4.9"
 
 
 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 1755525740 --verbose 0'
+    f'--expiration_timestamp 1758638079 --verbose 0'
 )

{kevin-toolbox-dev-1.4.7/kevin_toolbox/developing → kevin-toolbox-dev-1.4.9/kevin_toolbox/computer_science/algorithm}/decorator/__init__.py

@@ -1 +1,2 @@
-from .restore_original_work_path import restore_original_work_path
+from .restore_original_work_path import restore_original_work_path
+from .retry import retry

kevin-toolbox-dev-1.4.9/kevin_toolbox/computer_science/algorithm/decorator/retry.py

@@ -0,0 +1,62 @@
+import time
+import functools
+from kevin_toolbox.patches.for_logging import build_logger
+
+default_logger = build_logger(
+    name=":retry",
+    handler_ls=[
+        dict(target=None, level="INFO", formatter="%(name)s - %(levelname)s - %(message)s"),
+    ]
+)
+
+
+def retry(retries=3, delay=0.5, exceptions=(Exception,), logger=None):
+    """
+        在函数执行失败时，等待一定时间后重试多次
+
+        参数：
+            retries:            <int> 重试次数
+                                    默认重试3次
+            delay:              <int/float> 每次重试前等待的秒数
+                                    默认0.5秒
+            exceptions:         <list> 捕获的异常类型
+                                    默认捕获所有 Exception
+
+        使用示例：
+            @retry(retries=5, delay=2)
+            def func():
+                ...
+    """
+    logger = default_logger if logger == "default" else logger
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            last_exception = None
+            for attempt in range(1, retries + 1):
+                try:
+                    return func(*args, **kwargs)
+                except exceptions as e:
+                    last_exception = e
+                    if logger is not None:
+                        logger.info(f"第 {attempt} 次调用 {func.__name__} 失败\n\t异常：{e}\n\t等待 {delay} 秒后重试...")
+                    time.sleep(delay)
+            # 如果所有重试均失败，则抛出最后一次捕获的异常
+            raise last_exception
+
+        return wrapper
+
+    return decorator
+
+
+if __name__ == '__main__':
+    @retry(retries=2, delay=0.3, logger="default")
+    def func_(*args, **kwargs):
+        if args or kwargs:
+            return args, kwargs
+        else:
+            raise ValueError("no paras")
+
+
+    print(func_(123))
+    func_()

kevin-toolbox-dev-1.4.9/kevin_toolbox/computer_science/algorithm/registration/__init__.py

@@ -0,0 +1,2 @@
+from .registry import Registry, UNIFIED_REGISTRY
+from .serializer_for_registry_execution import Serializer_for_Registry_Execution, execution_serializer

kevin-toolbox-dev-1.4.9/kevin_toolbox/computer_science/algorithm/registration/serializer_for_registry_execution.py

@@ -0,0 +1,82 @@
+from kevin_toolbox.nested_dict_list import serializer
+from kevin_toolbox.computer_science.data_structure import Executor
+from kevin_toolbox.computer_science.algorithm.registration import Registry
+
+
+class Serializer_for_Registry_Execution:
+    """
+        用于对基于 Registry 中成员构建的执行过程进行序列化和反序列化操作
+            比如对于一个含有callable成员的 Registry，我们可以使用该 recorder 将其执行过程序列化保存下来，并在需要时恢复并执行
+
+        工作流程：
+                                recover() ---> executor ---> run to get result
+                                   ^
+                                   |
+            record(...) ---> self.record_s ---> save()
+                                   ^              |
+                                   |              v
+                                load() <---  record_file
+    """
+
+    def __init__(self):
+        self.record_s = None
+
+    def record(self, _name=None, _registry=None, *args, **kwargs):
+        """
+            将参数保存到 record_s 中
+        """
+        return self.record_name(_name, _registry).record_paras(*args, **kwargs)
+
+    def record_name(self, _name, _registry):
+        assert isinstance(_registry, (Registry,))
+        assert callable(_registry.get(name=_name, default=None))
+        self.record_s = self.record_s or dict()
+        self.record_s["name"] = _name
+        self.record_s["registry_uid"] = _registry.uid
+        return self
+
+    def record_paras(self, *args, **kwargs):
+        self.record_s = self.record_s or dict()
+        self.record_s["args"] = args
+        self.record_s["kwargs"] = kwargs
+        return self
+
+    def save(self, output_dir=None, b_pack_into_tar=False, b_allow_overwrite=False, **kwargs):
+        """
+            将 record_s 使用 ndl 持久化到文件中
+
+            参数：
+                output_dir:
+                b_pack_into_tar:
+                b_allow_overwrite:
+            其余未列出参数请参考 ndl.serializer.write 中的介绍，常用的有：
+                b_allow_overwrite
+                settings
+            等。
+        """
+        assert self.record_s is not None
+        file_path = serializer.write(var=self.record_s, output_dir=output_dir, b_pack_into_tar=b_pack_into_tar,
+                                     b_allow_overwrite=b_allow_overwrite, **kwargs)
+        return file_path
+
+    def load(self, input_path):
+        """
+            从文件中加载内容到 record_s
+        """
+        self.record_s = serializer.read(input_path=input_path)
+        return self
+
+    def recover(self, record_s=None):
+        """
+            根据 record_s 中的信息，结合 registry 构建一个执行器并返回
+        """
+        record_s = record_s or self.record_s
+        assert record_s is not None
+
+        func = Registry(uid=record_s["registry_uid"]).get(name=record_s["name"], default=None)
+        assert callable(func)
+        executor = Executor(func=func, args=record_s["args"], kwargs=record_s["kwargs"])
+        return executor
+
+
+execution_serializer = Serializer_for_Registry_Execution()

{kevin-toolbox-dev-1.4.7 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/data_flow/core/cache/cache_manager_for_iterator.py

@@ -1,7 +1,7 @@
 import os
 import time
 import importlib.util
-from kevin_toolbox.developing.decorator import restore_original_work_path
+from kevin_toolbox.computer_science.algorithm.decorator import restore_original_work_path
 from kevin_toolbox.computer_science.algorithm.cache_manager import Cache_Manager
 
 if importlib.util.find_spec("cPickle") is not None:

{kevin-toolbox-dev-1.4.7 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/data_flow/file/json_/write_json.py

@@ -56,7 +56,8 @@ def write_json(content, file_path, converters=None, b_use_suggested_converter=Fa
         content = traverse(var=[copy.deepcopy(content)],
                            match_cond=lambda _, __, ___: True, action_mode="replace",
                            converter=lambda _, x: converter(x),
-                           b_traverse_matched_element=True)[0]
+                           b_traverse_matched_element=True,
+                           b_skip_repeated_non_leaf_node=True)[0]
 
     content = json.dumps(content, **output_format)
 

{kevin-toolbox-dev-1.4.7 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/env_info/check_version_and_update.py

@@ -16,7 +16,6 @@ def check_version_and_update(package_name, cur_version=None, available_versions=
         ex = subprocess.Popen(f'pip list | grep "{package_name} "', shell=True, stdout=subprocess.PIPE)
         out, _ = ex.communicate()
         out = out.decode().strip()
-        # breakpoint()
         cur_version = out.split(package_name)[-1].strip()
 
     # try to read available versions

{kevin-toolbox-dev-1.4.7 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/env_info/variable_/env_vars_parser.py

@@ -26,10 +26,24 @@ class Env_Vars_Parser:
     def __call__(self, *args, **kwargs):
         return self.parse(*args, **kwargs)
 
-    def parse(self, text):
+    def parse(self, text, **kwargs):
         """
             解释并替换
+
+            参数：
+                default:        默认之。
+                                    当有设定时，若无法解释则返回该值。
+                                    否则，若无法解释将报错。
         """
+        if "default" in kwargs:
+            try:
+                return self.__parse(text=text)
+            except:
+                return kwargs["default"]
+        else:
+            return self.__parse(text=text)
+
+    def __parse(self, text):
         temp_ls = []
         for it in self.split_string(text=text):
             if isinstance(it, str):
@@ -85,4 +99,5 @@ class Env_Vars_Parser:
 
 if __name__ == '__main__':
     env_vars_parser = Env_Vars_Parser()
-    print(env_vars_parser.split_string("666/123${:VAR}/afasf/${/xxx.../xxx.json:111:222}336"))
+    # print(env_vars_parser.split_string("666/123${:VAR}/afasf/${/xxx.../xxx.json:111:222}336"))
+    print(env_vars_parser.parse("${KVT_PATCHES:for_matplotlib:common_charts:font_settings:for_non-windows-platform}"))

{kevin-toolbox-dev-1.4.7 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/nested_dict_list/copy_.py

@@ -123,7 +123,8 @@ def _copy_structure(var, b_keep_internal_references):
 
     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]
+                    traversal_mode="dfs_pre_order", b_traverse_matched_element=True,
+                    b_skip_repeated_non_leaf_node=True)[0]
 
 
 def _copy_nodes(var, b_keep_internal_references):
@@ -149,7 +150,8 @@ def _copy_nodes(var, b_keep_internal_references):
 
     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]
+                    traversal_mode="dfs_pre_order", b_traverse_matched_element=True,
+                    b_skip_repeated_non_leaf_node=True)[0]
 
 
 if __name__ == '__main__':

{kevin-toolbox-dev-1.4.7 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/nested_dict_list/get_nodes.py

@@ -2,7 +2,7 @@ from kevin_toolbox.nested_dict_list import traverse, get_value
 from kevin_toolbox.nested_dict_list.name_handler import parse_name
 
 
-def get_nodes(var, level=-1, b_strict=True):
+def get_nodes(var, level=-1, b_strict=True, **kwargs):
     """
         获取嵌套字典列表 var 中所有叶节点
             以列表 [(name,value), ...] 形式返回，其中名字 name 的解释方式参考 name_handler.parse_name() 介绍
@@ -23,6 +23,8 @@ def get_nodes(var, level=-1, b_strict=True):
                                     默认为 True，不添加。
     """
     assert isinstance(level, (int,))
+    kwargs.setdefault("b_skip_repeated_non_leaf_node", False)
+
     if level == 0:
         return [("", var)]
 
@@ -38,7 +40,7 @@ def get_nodes(var, level=-1, b_strict=True):
             res_empty.add(idx + "@None")  # 添加哨兵，表示空节点，并不会被实际解释
         return False
 
-    traverse(var=var, match_cond=func, action_mode="skip", b_use_name_as_idx=True)
+    traverse(var=var, match_cond=func, action_mode="skip", b_use_name_as_idx=True, **kwargs)
 
     if level != -1:
         names = set()

kevin-toolbox-dev-1.4.9/kevin_toolbox/nested_dict_list/serializer/variable.py

@@ -0,0 +1,20 @@
+import os
+from kevin_toolbox.computer_science.algorithm.registration import Registry
+
+SERIALIZER_BACKEND = Registry(uid="SERIALIZER_BACKEND")
+
+# 导入时的默认过滤规则
+ignore_s = [
+    {
+        "func": lambda _, __, path: os.path.basename(path) in ["temp", "test", "__pycache__",
+                                                               "_old_version"],
+        "scope": ["root", "dirs"]
+    },
+]
+
+# 从 kevin_toolbox/nested_dict_list/serializer/backends 下收集被注册的 backend
+SERIALIZER_BACKEND.collect_from_paths(
+    path_ls=[os.path.join(os.path.dirname(__file__), "backends"), ],
+    ignore_s=ignore_s,
+    b_execute_now=False
+)

{kevin-toolbox-dev-1.4.7 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/nested_dict_list/serializer/write.py

@@ -250,6 +250,8 @@ def write(var, output_dir, settings=None, traversal_mode=Traversal_Mode.BFS, b_p
     if not os.path.exists(tgt_path):
         for_os.copy(src=src_path, dst=tgt_path, remove_dst_if_exists=True)
 
+    return tgt_path
+
 
 def _judge_processed_or_not(processed_s, name):
     """

{kevin-toolbox-dev-1.4.7 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/nested_dict_list/traverse.py

@@ -15,7 +15,8 @@ class Traversal_Mode(Enum):
 
 
 def traverse(var, match_cond, action_mode="remove", converter=None,
-             b_use_name_as_idx=False, traversal_mode="dfs_pre_order", b_traverse_matched_element=False):
+             b_use_name_as_idx=False, traversal_mode="dfs_pre_order", b_traverse_matched_element=False,
+             b_skip_repeated_non_leaf_node=None, cond_for_repeated_leaf_to_skip=None, **kwargs):
     """
         遍历 var 找到符合 match_cond 的元素，将其按照 action_mode 指定的操作进行处理
 
@@ -48,46 +49,86 @@ def traverse(var, match_cond, action_mode="remove", converter=None,
                                     默认为 "dfs_pre_order"
             b_use_name_as_idx:  <boolean> 对于 match_cond/converter 中的 idx 参数，是传入整体的 name 还是父节点的 index 或 key。
                                     默认为 False
-            b_traverse_matched_element  <boolean> 对于匹配上的元素，经过处理后，是否继续遍历该元素的内容
+            b_traverse_matched_element: <boolean> 对于匹配上的元素，经过处理后，是否继续遍历该元素的内容
                                     默认为 False
+            b_skip_repeated_non_leaf_node:  <boolean> 是否跳过重复的非叶节点。
+                                    何为重复？
+                                        在内存中的id相同。
+                                    默认为 None，此时将根据 action_mode 的来决定：
+                                        - 对于会对节点进行修改的模式，比如 "remove" 和 "replace"，将设为 True，以避免预期外的重复转换和替换。
+                                        - 对于不会修改节点内容的模式，比如 "skip"，将设为 False。
+            cond_for_repeated_leaf_to_skip: <list/tuple of callable> 在叶节点位置上，遇到满足其中某个条件的重复的元素时需要跳过。
+                                    要求函数接受 叶节点的值，并返回一个 boolean，表示是否匹配成功。
+                                    默认为 None
     """
     assert callable(match_cond)
     action_mode = Action_Mode(action_mode)
     if action_mode is Action_Mode.REPLACE:
         assert callable(converter)
     traversal_mode = Traversal_Mode(traversal_mode)
+    if b_skip_repeated_non_leaf_node is None:
+        if action_mode is Action_Mode.SKIP:
+            b_skip_repeated_non_leaf_node = False
+        else:  # action_mode in (Action_Mode.REMOVE, Action_Mode.REPLACE)
+            b_skip_repeated_non_leaf_node = True
+    cond_for_repeated_leaf_to_skip = [] if cond_for_repeated_leaf_to_skip is None else cond_for_repeated_leaf_to_skip
+
+    passed_node_ids = {"leaf": set(), "non_leaf": set()}
 
     if traversal_mode is Traversal_Mode.BFS:
-        return _bfs(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element)
+        return _bfs(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element,
+                    b_skip_repeated_non_leaf_node=b_skip_repeated_non_leaf_node,
+                    cond_for_repeated_leaf_to_skip=cond_for_repeated_leaf_to_skip,
+                    passed_node_ids=passed_node_ids)
     else:
         return _dfs(var, match_cond, action_mode, converter, b_use_name_as_idx, traversal_mode,
-                    b_traverse_matched_element, "")
+                    b_traverse_matched_element, pre_name="",
+                    b_skip_repeated_non_leaf_node=b_skip_repeated_non_leaf_node,
+                    cond_for_repeated_leaf_to_skip=cond_for_repeated_leaf_to_skip,
+                    passed_node_ids=passed_node_ids)
 
 
-def _bfs(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element):
+def _bfs(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element,
+         b_skip_repeated_non_leaf_node, cond_for_repeated_leaf_to_skip, passed_node_ids):
     temp = [("", var)]
 
     while len(temp):
-        pre_name, i = temp.pop(0)
-        if isinstance(i, (list, dict)):
-            keys = list(range(len(i)) if isinstance(i, list) else i.keys())
+        pre_name, it = temp.pop(0)
+        if isinstance(it, (list, dict)):
+            #
+            if b_skip_repeated_non_leaf_node:
+                if id(it) in passed_node_ids["non_leaf"]:
+                    continue
+                else:
+                    passed_node_ids["non_leaf"].add(id(it))
+            #
+            keys = list(range(len(it)) if isinstance(it, list) else it.keys())
             keys.reverse()  # 反过来便于 列表 弹出元素
-            idx_ls = _gen_idx(i, keys, b_use_name_as_idx, pre_name)
+            idx_ls = _gen_idx(it, keys, b_use_name_as_idx, pre_name)
 
             # 匹配&处理
             for k, idx in zip(keys, idx_ls):
-                b_matched, b_popped = _deal(i, k, idx, match_cond, converter, action_mode)
-                if b_popped or (b_matched and not b_traverse_matched_element):
+                b_matched, b_popped, b_skip = _deal(it, k, idx, match_cond, converter, action_mode,
+                                                    cond_for_repeated_leaf_to_skip, passed_node_ids)
+                if b_skip or b_popped or (b_matched and not b_traverse_matched_element):
                     continue
                 # 添加到队尾
-                temp.append((idx, i[k]))
+                temp.append((idx, it[k]))
 
     return var
 
 
 def _dfs(var, match_cond, action_mode, converter,
-         b_use_name_as_idx, traversal_mode, b_traverse_matched_element, pre_name):
+         b_use_name_as_idx, traversal_mode, b_traverse_matched_element, pre_name,
+         b_skip_repeated_non_leaf_node, cond_for_repeated_leaf_to_skip, passed_node_ids):
     if isinstance(var, (list, dict)):
+        #
+        if b_skip_repeated_non_leaf_node:
+            if id(var) in passed_node_ids["non_leaf"]:
+                return var
+            else:
+                passed_node_ids["non_leaf"].add(id(var))
+        #
         keys = list(range(len(var)) if isinstance(var, list) else var.keys())
         keys.reverse()  # 反过来便于 列表 弹出元素
         idx_ls = _gen_idx(var, keys, b_use_name_as_idx, pre_name)
@@ -98,29 +139,42 @@ def _dfs(var, match_cond, action_mode, converter,
             # 匹配&处理
             deal_res_ls = []
             for k, idx in zip(keys, idx_ls):
-                deal_res_ls.append(_deal(var, k, idx, match_cond, converter, action_mode))
+                deal_res_ls.append(_deal(var, k, idx, match_cond, converter, action_mode,
+                                         cond_for_repeated_leaf_to_skip, passed_node_ids))
             # 递归遍历
-            for (b_matched, b_popped), k, idx in zip(deal_res_ls, keys, idx_ls):
-                if b_popped or (b_matched and not b_traverse_matched_element):
+            for (b_matched, b_popped, b_skip), k, idx in zip(deal_res_ls, keys, idx_ls):
+                if b_skip or b_popped or (b_matched and not b_traverse_matched_element):
                     continue
                 var[k] = _dfs(var[k], match_cond, action_mode, converter, b_use_name_as_idx, traversal_mode,
-                              b_traverse_matched_element, idx)
+                              b_traverse_matched_element, idx,
+                              b_skip_repeated_non_leaf_node, cond_for_repeated_leaf_to_skip, passed_node_ids)
         else:
             # 后序
             # 递归遍历
             for k, idx in zip(keys, idx_ls):
                 var[k] = _dfs(var[k], match_cond, action_mode, converter, b_use_name_as_idx, traversal_mode,
-                              b_traverse_matched_element, idx)
+                              b_traverse_matched_element, idx,
+                              b_skip_repeated_non_leaf_node, cond_for_repeated_leaf_to_skip, passed_node_ids)
             # 匹配&处理
             for k, idx in zip(keys, idx_ls):
-                _deal(var, k, idx, match_cond, converter, action_mode)
+                _deal(var, k, idx, match_cond, converter, action_mode,
+                      cond_for_repeated_leaf_to_skip, passed_node_ids)
     else:
         pass
     return var
 
 
-def _deal(var, k, idx, match_cond, converter, action_mode):
+def _deal(var, k, idx, match_cond, converter, action_mode,
+          cond_for_repeated_leaf_to_skip, passed_node_ids):
     """处理节点"""
+    b_skip = False
+
+    if cond_for_repeated_leaf_to_skip and not isinstance(var[k], (dict, list,)) and any(
+            [i(var[k]) for i in cond_for_repeated_leaf_to_skip]):
+        if id(var[k]) in passed_node_ids["leaf"]:
+            return None, None, True
+        else:
+            passed_node_ids["leaf"].add(id(var[k]))
     # 匹配
     b_matched = match_cond(type(var), idx, var[k])
     b_popped = False
@@ -133,7 +187,7 @@ def _deal(var, k, idx, match_cond, converter, action_mode):
             var[k] = converter(idx, var[k])
         else:
             pass
-    return b_matched, b_popped
+    return b_matched, b_popped, b_skip
 
 
 def _gen_idx(var, keys, b_use_name_as_idx, pre_name):

{kevin-toolbox-dev-1.4.7 → kevin-toolbox-dev-1.4.9}/kevin_toolbox/nested_dict_list/value_parser/replace_identical_with_reference.py

@@ -70,10 +70,7 @@ def _forward(var, flag, match_cond):
         # 任选其一进行保留，其余改为引用
         keep_name = unprocessed_name_set.pop()
         for name in unprocessed_name_set:
-            try:
-                var = set_value(var=var, name=name, value=f'<{flag}>{{{keep_name}}}', b_force=False)
-            except:
-                breakpoint()
+            var = set_value(var=var, name=name, value=f'<{flag}>{{{keep_name}}}', b_force=False)
         processed_name_set.update(unprocessed_name_set)
 
     # 将叶节点中，未被处理过，且是 str，且以 flag 开头的字符串，添加多一个 flag，以示区分

kevin-toolbox-dev-1.4.9/kevin_toolbox/network/__init__.py

@@ -0,0 +1,10 @@
+import urllib3
+from urllib3.exceptions import InsecureRequestWarning
+
+# 禁用不安全请求警告（例如当 verify=False 时）
+urllib3.disable_warnings(InsecureRequestWarning)
+
+from .get_response import get_response
+from .fetch_metadata import fetch_metadata
+from .fetch_content import fetch_content
+from .download_file import download_file