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

kevin-toolbox-dev-1.4.7/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.4.7
+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.7 （2025-02-19）【new feature】【bug fix】【incompatible change】
+
+  - data_flow.file
+    - 【new feature】【incompatible change】modify json_.write()，支持使用参数 output_format 设置更复杂的输出格式。同时废弃原来的sort_keys参数。
+      - output_format 支持以下输入：
+        - "pretty_printed":     通过添加大量的空格和换行符来格式化输出，使输出更易读
+        - "minified":           删除所有空格和换行符，使输出更紧凑
+        - `<dict/tuple>`：     更加细致的格式设定，比如 `{"indent": 2, ensure_ascii=True}`，如果需要基于已有格式进行微调可以使用以下方式:`("pretty_printed", {"indent": 2, ensure_ascii=True})`
+  - computer_science.algorithm.parallel_and_concurrent
+    - 【bug fix】【incompatible change】fix bug in multi_thread_execute()，修正了参数timeout无法对每个任务起效的bug，将参数thread_nums更名为worker_nums。
+    - 【new feature】add multi_process_execute()，用于多进程执行任务。同样支持timeout设定和进度条显示。
+  - patches.for_matplotlib.common_charts
+    - modify plot_lines()，添加了 x_ticklabels_name 参数用于自定义x轴的坐标值
+  - 以上修改，均已添加了对应的测试用例。
+
+

kevin-toolbox-dev-1.4.7/README.md

@@ -0,0 +1,43 @@
+# 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.7 （2025-02-19）【new feature】【bug fix】【incompatible change】
+
+  - data_flow.file
+    - 【new feature】【incompatible change】modify json_.write()，支持使用参数 output_format 设置更复杂的输出格式。同时废弃原来的sort_keys参数。
+      - output_format 支持以下输入：
+        - "pretty_printed":     通过添加大量的空格和换行符来格式化输出，使输出更易读
+        - "minified":           删除所有空格和换行符，使输出更紧凑
+        - `<dict/tuple>`：     更加细致的格式设定，比如 `{"indent": 2, ensure_ascii=True}`，如果需要基于已有格式进行微调可以使用以下方式:`("pretty_printed", {"indent": 2, ensure_ascii=True})`
+  - computer_science.algorithm.parallel_and_concurrent
+    - 【bug fix】【incompatible change】fix bug in multi_thread_execute()，修正了参数timeout无法对每个任务起效的bug，将参数thread_nums更名为worker_nums。
+    - 【new feature】add multi_process_execute()，用于多进程执行任务。同样支持timeout设定和进度条显示。
+  - patches.for_matplotlib.common_charts
+    - modify plot_lines()，添加了 x_ticklabels_name 参数用于自定义x轴的坐标值
+  - 以上修改，均已添加了对应的测试用例。

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

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

{kevin-toolbox-dev-1.4.5 → kevin-toolbox-dev-1.4.7}/kevin_toolbox/computer_science/algorithm/cache_manager/cache_manager.py

@@ -44,6 +44,12 @@ class Cache_Manager:
                                             当设置为 float 时表示占 upper_bound 的比例
                                             默认为 0.5
                 strategy:               <str/dict/Strategy_Base> 管理策略
+                                            目前支持以下策略：
+                                                - ":by_initial_time:FIFO"     删除最后一次访问时间最久远的部分
+                                                - ":by_counts:LFU"            删除访问频率最低的部分
+                                                - ":by_last_time:LRU"          删除最后一次访问时间最久远的部分
+                                                - ":by_survival_time:LST"      删除访问频率最低的部分
+                                            默认使用 LRU 策略
                 cache:                  <str/dict/Cache_Base> 缓存种类
         """
         # 默认参数

kevin-toolbox-dev-1.4.7/kevin_toolbox/computer_science/algorithm/parallel_and_concurrent/__init__.py

@@ -0,0 +1,2 @@
+from .multi_thread_execute import multi_thread_execute
+from .multi_process_execute import multi_process_execute

kevin-toolbox-dev-1.4.7/kevin_toolbox/computer_science/algorithm/parallel_and_concurrent/multi_process_execute.py

@@ -0,0 +1,109 @@
+import pickle
+import concurrent.futures
+from multiprocessing import Manager
+from kevin_toolbox.computer_science.data_structure import Executor
+from kevin_toolbox.computer_science.algorithm.parallel_and_concurrent.utils import wrapper_for_mp as wrapper
+from kevin_toolbox.computer_science.algorithm.parallel_and_concurrent.utils import DEFAULT_PROCESS_NUMS
+
+
+def multi_process_execute(executors, worker_nums=DEFAULT_PROCESS_NUMS, b_display_progress=True, timeout=None,
+                          _hook_for_debug=None):
+    """
+        多进程执行
+
+        参数：
+            executors:                  <list/generator/iterator of Executor> 执行器序列
+            worker_nums:                <int> 进程数
+            b_display_progress:         <boolean> 是否显示进度条
+            timeout:                    <int/float> 每个进程的最大等待时间，单位是s
+                                            默认为 None，表示允许等待无限长的时间
+            _hook_for_debug:            <dict/None> 当设置为非 None 值时，将保存中间的执行信息。
+                                            包括：
+                                                - "execution_orders":    执行顺序
+                                                - "completion_orders":   完成顺序
+                                            这些信息与最终结果无关，仅面向更底层的调试需求，任何人都不应依赖该特性
+        返回：
+            res_ls, failed_idx_ls
+            执行结果列表，以及执行失败的执行器索引列表
+    """
+    executor_ls = []
+    for i in executors:
+        assert isinstance(i, (Executor,))
+        try:
+            pickle.dumps(i)
+        except:
+            raise AttributeError(
+                f'非法任务。因为进程池中的任务必须要能被pickle化。\n对象 {i} 无法被 pickle，请检查其中是否使用了闭包内定义的函数')
+        executor_ls.append(i)
+    if b_display_progress:
+        from tqdm import tqdm
+        p_bar = tqdm(total=len(executor_ls))
+    else:
+        p_bar = None
+
+    if isinstance(_hook_for_debug, dict):
+        _execution_orders, _completion_orders = Manager().list(), Manager().list()
+    else:
+        _execution_orders, _completion_orders = None, None
+
+    res_ls = [None] * len(executor_ls)
+    failed_idx_ls = []
+    with concurrent.futures.ProcessPoolExecutor(max_workers=worker_nums) as process_pool:
+        # 提交任务并添加进度回调
+        futures = []
+        for i, executor in enumerate(executor_ls):
+            future = process_pool.submit(wrapper, executor, timeout, i, _execution_orders, _completion_orders)
+            if b_display_progress:
+                future.add_done_callback(lambda _: p_bar.update())
+            futures.append(future)
+
+        # 收集结果
+        for i, future in enumerate(futures):
+            try:
+                res, b_success = future.result()
+            except:
+                b_success = False
+            if b_success:
+                res_ls[i] = res
+            else:
+                failed_idx_ls.append(i)
+
+    if b_display_progress:
+        p_bar.close()
+
+    if isinstance(_hook_for_debug, (dict,)):
+        _hook_for_debug.update({
+            "execution_orders": list(_execution_orders),
+            "completion_orders": list(_completion_orders)
+        })
+
+    return res_ls, failed_idx_ls
+
+
+if __name__ == '__main__':
+    import time
+
+
+    def func_(i):
+        # 模拟部分任务长时间运行，部分任务正常结束
+        if i in [2, 3, 7]:
+            time.sleep(100)
+        else:
+            time.sleep(0.01)
+        print(f"任务 {i} 执行完成")
+        return i * 2
+
+
+    hook_for_debug = dict()
+    a = time.time()
+    results, failed = multi_process_execute(
+        executors=[Executor(func=func_, args=(i,)) for i in range(10)],
+        worker_nums=10,
+        timeout=0.2,
+        _hook_for_debug=hook_for_debug
+    )
+    gap = time.time() - a
+    print("执行结果:", results)
+    print("超时失败的任务索引:", failed)
+    print("调试信息:", hook_for_debug)
+    print("总耗时:", gap)

kevin-toolbox-dev-1.4.7/kevin_toolbox/computer_science/algorithm/parallel_and_concurrent/multi_thread_execute.py

@@ -0,0 +1,105 @@
+import concurrent.futures
+from multiprocessing import Manager
+from kevin_toolbox.computer_science.data_structure import Executor
+from kevin_toolbox.computer_science.algorithm.parallel_and_concurrent.utils import wrapper_for_mt as wrapper
+from kevin_toolbox.computer_science.algorithm.parallel_and_concurrent.utils import DEFAULT_THREAD_NUMS
+
+
+def multi_thread_execute(executors, worker_nums=DEFAULT_THREAD_NUMS, b_display_progress=True, timeout=None,
+                         _hook_for_debug=None):
+    """
+        多线程执行
+
+        参数：
+            executors:                  <list/generator/iterator of Executor> 执行器序列
+            worker_nums:                <int> 线程数
+            b_display_progress:         <boolean> 是否显示进度条
+            timeout:                    <int> 每个线程的最大等待时间，单位是s
+                                            默认为 None，表示允许等待无限长的时间
+            _hook_for_debug:            <dict/None> 当设置为非 None 值时，将保存中间的执行信息。
+                                            包括：
+                                                - "execution_order":    执行顺序
+                                                - "completion_order":   完成顺序
+                                            这些信息与最终结果无关，仅面向更底层的调试需求，任何人都不应依赖该特性
+        返回：
+            res_ls, failed_idx_ls
+            执行结果列表，执行失败的执行器 idx
+    """
+    executor_ls = []
+    for i in executors:
+        assert isinstance(i, (Executor,))
+        executor_ls.append(i)
+    if b_display_progress:
+        from tqdm import tqdm
+        p_bar = tqdm(total=len(executor_ls))
+    else:
+        p_bar = None
+
+    if isinstance(_hook_for_debug, dict):
+        _execution_orders, _completion_orders = Manager().list(), Manager().list()
+    else:
+        _execution_orders, _completion_orders = None, None
+
+    res_ls = [None] * len(executor_ls)
+    failed_idx_ls = []
+    with concurrent.futures.ThreadPoolExecutor(max_workers=worker_nums) as thread_pool:
+        # 提交任务
+        futures = []
+        for i, executor in enumerate(executor_ls):
+            future = thread_pool.submit(wrapper, executor, timeout, i, _execution_orders, _completion_orders)
+            if b_display_progress:
+                future.add_done_callback(lambda _: p_bar.update())
+            futures.append(future)
+
+        # 收集结果
+        for i, future in enumerate(futures):
+            try:
+                res, b_success = future.result()
+            except:
+                b_success = False
+            if b_success:
+                res_ls[i] = res
+            else:
+                failed_idx_ls.append(i)
+
+    if b_display_progress:
+        p_bar.close()
+
+    if isinstance(_hook_for_debug, (dict,)):
+        _hook_for_debug.update({
+            "execution_orders": list(_execution_orders),
+            "completion_orders": list(_completion_orders)
+        })
+
+    return res_ls, failed_idx_ls
+
+
+if __name__ == '__main__':
+    import time
+
+
+    def func_(i):
+        # 模拟部分任务长时间运行，部分任务正常结束
+        if i in [2, 3, 7]:
+            time.sleep(100)
+        elif i in [4, 5, 6]:
+            time.sleep(0.01)
+        else:
+            time.sleep(0.05)
+        print(f"任务 {i} 执行完成")
+        return i * 2
+
+
+    hook_for_debug = dict()
+    a = time.time()
+    results, failed = multi_thread_execute(
+        executors=[Executor(func=func_, args=(i,)) for i in range(10)],
+        worker_nums=5,
+        timeout=0.2,
+        _hook_for_debug=hook_for_debug
+    )
+    gap = time.time() - a
+    print("执行结果:", results)
+    print("超时失败的任务索引:", failed)
+    print("调试信息:", hook_for_debug)
+    print("总耗时:", gap)

kevin-toolbox-dev-1.4.7/kevin_toolbox/computer_science/algorithm/parallel_and_concurrent/utils/__init__.py

@@ -0,0 +1,15 @@
+from .wrapper_with_timeout_1 import wrapper_with_timeout_1
+from .wrapper_with_timeout_2 import wrapper_with_timeout_2
+
+import signal
+import multiprocessing
+
+if callable(getattr(signal, "setitimer", None)):
+    wrapper_for_mp = wrapper_with_timeout_1  # 效率更高，优先选择
+else:
+    wrapper_for_mp = wrapper_with_timeout_2
+
+wrapper_for_mt = wrapper_with_timeout_2
+
+DEFAULT_PROCESS_NUMS = multiprocessing.cpu_count() + 2
+DEFAULT_THREAD_NUMS = DEFAULT_PROCESS_NUMS * 2

kevin-toolbox-dev-1.4.7/kevin_toolbox/computer_science/algorithm/parallel_and_concurrent/utils/wrapper_with_timeout_1.py

@@ -0,0 +1,69 @@
+import signal
+
+
+# 定义超时异常
+class TimeoutException(Exception):
+    pass
+
+
+# 定时器信号处理函数
+def __alarm_handler(*args, **kwargs):
+    raise TimeoutException("任务超时")
+
+
+def wrapper_with_timeout_1(executor, timeout=None, idx=-1, _execution_orders=None, _completion_orders=None):
+    """
+        限制执行时间，使用 multiprocessing.Process 强制终止超时任务
+            该函数仅适用于多进程以及 unix 操作系统
+
+        参数:
+            executor:               <Executor>执行器，需实现 run() 方法
+            idx:                    <int> 任务索引（用于调试）
+            timeout:                <int/float>最大等待时间（单位：秒，支持 float）
+            _execution_orders, _completion_orders: 用于记录调试信息的 Manager.list
+        返回:
+            (result, b_success)     若超时或异常则 b_success 为 False
+    """
+    if _execution_orders is not None:
+        _execution_orders.append(idx)
+
+    # 定时器
+    if timeout is not None:
+        signal.signal(signal.SIGALRM, __alarm_handler)
+        signal.setitimer(signal.ITIMER_REAL, timeout)
+
+    # 执行
+    res, b_success = None, True
+    try:
+        res = executor.run()
+        if _completion_orders is not None:
+            _completion_orders.append(idx)
+    except TimeoutException:
+        b_success = False
+    finally:
+        signal.alarm(0)  # 取消定时器
+    return res, b_success
+
+
+if __name__ == '__main__':
+    import time
+
+
+    def func_(i):
+        if i in [2, 3, 7]:
+            time.sleep(300)
+        else:
+            time.sleep(0.5)
+        return i * 2
+
+
+    from kevin_toolbox.computer_science.data_structure import Executor
+
+    print(wrapper_with_timeout_1(Executor(func=func_, args=(2,)), timeout=1))
+    print(wrapper_with_timeout_1(Executor(func=func_, args=(1,)), timeout=1))
+
+    execution_orders = []
+    completion_orders = []
+    print(wrapper_with_timeout_1(Executor(func=func_, args=(2,)), timeout=1, _execution_orders=execution_orders,
+                                 _completion_orders=completion_orders))
+    print(execution_orders, completion_orders)

kevin-toolbox-dev-1.4.7/kevin_toolbox/computer_science/algorithm/parallel_and_concurrent/utils/wrapper_with_timeout_2.py

@@ -0,0 +1,76 @@
+from multiprocessing import Process, Queue
+
+
+def __inner_wrapper(q, executor):
+    try:
+        res = executor.run()
+        q.put((res, True))
+    except:
+        q.put((None, False))
+
+
+def wrapper_with_timeout_2(executor, timeout=None, idx=-1, _execution_orders=None, _completion_orders=None):
+    """
+        限制执行时间，使用 multiprocessing.Process 强制终止超时任务
+            该函数适用于多线程、多进程以及所有操作系统，但是效率相较于 wrapper_with_timeout_1 较差
+
+        参数:
+            executor:               <Executor>执行器，需实现 run() 方法
+            idx:                    <int> 任务索引（用于调试）
+            timeout:                <int/float>最大等待时间（单位：秒，支持 float）
+            _execution_orders, _completion_orders: 用于记录调试信息的 Manager.list
+        返回:
+            (result, b_success)     若超时或异常则 b_success 为 False
+    """
+    if _execution_orders is not None:
+        _execution_orders.append(idx)
+
+    res, b_success = None, False
+    if timeout is not None:
+        q = Queue()
+        p = Process(target=__inner_wrapper, args=(q, executor))
+        p.start()
+        p.join(timeout)  # 最多等待 timeout 秒
+
+        if q.qsize():
+            try:
+                res, b_success = q.get_nowait()
+            except:
+                pass
+        if p.is_alive():
+            p.terminate()
+            p.join()
+    else:
+        try:
+            res, b_success = executor.run(), True
+        except:
+            pass
+
+    if b_success:
+        if _completion_orders is not None:
+            _completion_orders.append(idx)
+    return res, b_success
+
+
+if __name__ == '__main__':
+    import time
+
+
+    def func_(i):
+        if i in [2, 3, 7]:
+            time.sleep(300)
+        else:
+            time.sleep(0.5)
+        return i * 2
+
+
+    from kevin_toolbox.computer_science.data_structure import Executor
+
+    print(wrapper_with_timeout_2(Executor(func=func_, args=(2,)), timeout=1))
+    print(wrapper_with_timeout_2(Executor(func=func_, args=(1,)), timeout=1))
+
+    execution_orders = []
+    completion_orders = []
+    print(wrapper_with_timeout_2(Executor(func=func_, args=(2,)), timeout=1, _execution_orders=execution_orders,
+                                 _completion_orders=completion_orders))
+    print(execution_orders, completion_orders)

{kevin-toolbox-dev-1.4.5 → kevin-toolbox-dev-1.4.7}/kevin_toolbox/computer_science/data_structure/executor.py

@@ -83,7 +83,7 @@ class Executor:
         # 校验参数
         # func
         assert paras["func"] is None or callable(paras["func"]), \
-            f"func should be callable, but get a {type(func)}"
+            f'func should be callable, but get a {type(paras["func"])}'
         # args
         assert isinstance(paras["args"], (list, tuple,)) and isinstance(paras["f_args"], (list, tuple,))
         for i, f in enumerate(paras["f_args"]):
@@ -93,7 +93,7 @@ class Executor:
         assert isinstance(paras["kwargs"], (dict,)) and isinstance(paras["f_kwargs"], (dict,))
         for k, v in paras["f_kwargs"].items():
             assert callable(v) and isinstance(k, (str,)), \
-                f"item {key} in f_kwargs should be (str, callable) pairs, but get a ({type(key)}, {type(v)})"
+                f"item {k} in f_kwargs should be (str, callable) pairs, but get a ({type(k)}, {type(v)})"
 
         # update paras
         self.paras = paras

kevin-toolbox-dev-1.4.7/kevin_toolbox/data_flow/file/excel/__init__.py

@@ -0,0 +1 @@
+from .write_excel_with_matrix import write_excel_with_matrix as write_with_matrix

kevin-toolbox-dev-1.4.7/kevin_toolbox/data_flow/file/excel/write_excel_with_matrix.py

@@ -0,0 +1,105 @@
+import os
+import openpyxl
+from openpyxl.styles import Alignment, Font, PatternFill
+from kevin_toolbox.patches.for_os import remove
+
+
+# excel
+def write_excel_with_matrix(matrix, file_path=None, file_obj=None, sheet_name="matrix",
+                            column_label_ls=None, row_label_ls=None, column_title="", row_title="", main_title=""):
+    """
+        将矩阵写入到 excel 文件中
+
+        参数:
+            file_path:                      要写入到哪个文件
+            file_obj:                       <openpyxl.Workbook> 文件对象
+                    注意！！以上两个参数指定其一即可，同时指定时候，以后者为准。
+            sheet_name:                     要写入到哪个sheet页面
+            matrix:                         <np.array or np.matrix> 矩阵
+            column_label_ls, row_label_ls:  行列标签
+            column_title, row_title:        行列标题
+            main_title:                     总标题
+    """
+    assert file_path is not None or file_obj is not None
+
+    if file_obj is None:
+        file_path = os.path.abspath(os.path.expanduser(file_path))
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        # 判断文件是否存在，不存在则新建，否则读取文件
+        if not os.path.isfile(file_path):
+            wb = openpyxl.Workbook()  # 创建文件对象
+            # wb对象创建后，默认含有一个默认的名为 Sheet 的 页面,将其删除
+            ws_ = wb.active
+            wb.remove(ws_)
+        else:
+            wb = openpyxl.load_workbook(file_path)
+    else:
+        assert isinstance(file_obj, openpyxl.Workbook)
+        wb = file_obj
+    # 判断sheet是否存在，不存在则建立，否则先删除再建立
+    if sheet_name in wb.sheetnames:
+        ws = wb[sheet_name]
+        wb.remove(ws)
+    ws = wb.create_sheet(sheet_name)
+
+    # 开始写
+    matrix_r_offset, matrix_c_offset = 1, 1  # 矩阵的起始位置
+    r_offset, c_offset = 1, 1  # 目前的写入位置
+    for i in [main_title, column_title, column_label_ls]:
+        if i:
+            matrix_r_offset += 1
+    for j in [row_title, row_label_ls]:
+        if j:
+            matrix_c_offset += 1
+    # print(matrix)
+    matrix_row_num, matrix_column_num = matrix.shape[0], matrix.shape[1]
+    # 标题
+    alignment = Alignment(horizontal="center", vertical="center", wrap_text=True)
+    if main_title:
+        ws.merge_cells(start_row=r_offset, start_column=1, end_row=r_offset,
+                       end_column=matrix_c_offset + matrix_column_num - 1)
+        ws.cell(row=r_offset, column=1).value = main_title
+        ws.cell(row=r_offset, column=1).alignment = alignment
+        ws.cell(row=r_offset, column=1).font = Font(size=10, bold=True, name='微软雅黑', color="000000")
+        r_offset += 1
+    if column_title:
+        ws.merge_cells(start_row=r_offset, start_column=matrix_c_offset, end_row=r_offset,
+                       end_column=matrix_c_offset + matrix_column_num - 1)
+        ws.cell(row=r_offset, column=matrix_c_offset).value = column_title
+        ws.cell(row=r_offset, column=matrix_c_offset).alignment = alignment
+        ws.cell(row=r_offset, column=matrix_c_offset).font = Font(size=10, bold=True, name='微软雅黑', color="000000")
+        r_offset += 1
+    if row_title:
+        ws.merge_cells(start_row=matrix_r_offset, start_column=1, end_row=matrix_r_offset + matrix_row_num - 1,
+                       end_column=1)
+        ws.cell(row=matrix_r_offset, column=1).value = row_title
+        ws.cell(row=matrix_r_offset, column=1).alignment = alignment
+        ws.cell(row=matrix_r_offset, column=1).font = Font(size=10, bold=True, name='微软雅黑', color="000000")
+        c_offset += 1
+    # 标签
+    if column_label_ls:
+        for i in range(matrix_column_num):
+            ws.cell(row=r_offset, column=matrix_c_offset + i).value = column_label_ls[i]
+            ws.cell(row=r_offset, column=matrix_c_offset + i).alignment = alignment
+            ws.cell(row=r_offset, column=matrix_c_offset + i).fill = PatternFill(patternType="solid",
+                                                                                 start_color="33CCFF")
+        r_offset += 1
+    if row_label_ls:
+        for i in range(matrix_row_num):
+            ws.cell(row=matrix_r_offset + i, column=c_offset).value = row_label_ls[i]
+            ws.cell(row=matrix_r_offset + i, column=c_offset).alignment = alignment
+            ws.cell(row=matrix_r_offset + i, column=c_offset).fill = PatternFill(patternType="solid",
+                                                                                 start_color="33CCFF")
+        c_offset += 1
+    # 校验，可省略
+    if not (c_offset == matrix_c_offset and r_offset == matrix_r_offset):
+        print("wrong here")
+    for r_ in range(matrix_row_num):
+        for c_ in range(matrix_column_num):
+            ws.cell(row=matrix_r_offset + r_, column=matrix_c_offset + c_).value = matrix[r_][c_]
+
+    if file_path is not None:
+        remove(file_path, ignore_errors=True)
+        wb.save(file_path)
+
+    return wb

{kevin-toolbox-dev-1.4.5 → kevin-toolbox-dev-1.4.7}/kevin_toolbox/data_flow/file/json_/read_json.py

@@ -23,6 +23,7 @@ def read_json(file_path=None, file_obj=None, converters=None, b_use_suggested_co
     """
     assert file_path is not None or file_obj is not None
     if file_path is not None:
+        file_path = os.path.abspath(os.path.expanduser(file_path))
         assert os.path.isfile(file_path), f'file {file_path} not found'
         file_obj = open(file_path, 'r')
     elif isinstance(file_obj, (BytesIO,)):