kevin-toolbox-dev 1.4.5__py3-none-any.whl → 1.4.7__py3-none-any.whl

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/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/computer_science/algorithm/parallel_and_concurrent/__init__.py

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

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/computer_science/algorithm/parallel_and_concurrent/multi_thread_execute.py

@@ -1,14 +1,18 @@
 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, thread_nums=50, b_display_progress=True, timeout=None, _hook_for_debug=None):
+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> 执行器序列
-            thread_nums:                <int> 线程数
+            worker_nums:                <int> 线程数
             b_display_progress:         <boolean> 是否显示进度条
             timeout:                    <int> 每个线程的最大等待时间，单位是s
                                             默认为 None，表示允许等待无限长的时间
@@ -30,37 +34,42 @@ def multi_thread_execute(executors, thread_nums=50, b_display_progress=True, tim
         p_bar = tqdm(total=len(executor_ls))
     else:
         p_bar = None
-    _execution_orders, _completion_orders = [], []
 
-    def wrapper(executor, idx):
-        nonlocal p_bar, _execution_orders, _completion_orders
-        _execution_orders.append(idx)
-        res = executor.run()
-        _completion_orders.append(idx)
-        if p_bar is not None:
-            p_bar.update()
-
-        return res
+    if isinstance(_hook_for_debug, dict):
+        _execution_orders, _completion_orders = Manager().list(), Manager().list()
+    else:
+        _execution_orders, _completion_orders = None, None
 
-    res_ls, failed_idx_ls = [], []
-    with concurrent.futures.ThreadPoolExecutor(max_workers=thread_nums) as thread_pool:
+    res_ls = [None] * len(executor_ls)
+    failed_idx_ls = []
+    with concurrent.futures.ThreadPoolExecutor(max_workers=worker_nums) as thread_pool:
         # 提交任务
-        futures = [thread_pool.submit(wrapper, executor, i) for i, executor in enumerate(executors)]
-        # 设置超时时间
-        concurrent.futures.wait(futures, timeout=timeout)
-        # 
+        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):
-            if future.done() and not future.cancelled():
-                res_ls.append(future.result())
+            try:
+                res, b_success = future.result()
+            except:
+                b_success = False
+            if b_success:
+                res_ls[i] = res
             else:
-                res_ls.append(None)
                 failed_idx_ls.append(i)
+
     if b_display_progress:
         p_bar.close()
 
-    #
     if isinstance(_hook_for_debug, (dict,)):
-        _hook_for_debug.update(dict(execution_orders=_execution_orders, completion_orders=_completion_orders))
+        _hook_for_debug.update({
+            "execution_orders": list(_execution_orders),
+            "completion_orders": list(_completion_orders)
+        })
 
     return res_ls, failed_idx_ls
 
@@ -70,15 +79,27 @@ if __name__ == '__main__':
 
 
     def func_(i):
+        # 模拟部分任务长时间运行，部分任务正常结束
         if i in [2, 3, 7]:
-            time.sleep(10)
+            time.sleep(100)
+        elif i in [4, 5, 6]:
+            time.sleep(0.01)
         else:
-            time.sleep(2)
-        print(i)
+            time.sleep(0.05)
+        print(f"任务 {i} 执行完成")
         return i * 2
 
 
     hook_for_debug = dict()
-    print(multi_thread_execute(executors=[Executor(func=func_, args=(i,)) for i in range(10)], thread_nums=5,
-                               _hook_for_debug=hook_for_debug))
-    print(hook_for_debug)
+    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/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/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/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/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/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/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/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,)):

kevin_toolbox/data_flow/file/json_/write_json.py

@@ -4,8 +4,13 @@ import copy
 from kevin_toolbox.data_flow.file.json_.converter import integrate, escape_tuple_and_set, escape_non_str_dict_key
 from kevin_toolbox.nested_dict_list import traverse
 
+format_s = {
+    "pretty_printed": dict(indent=4, ensure_ascii=False, sort_keys=False),
+    "minified": dict(indent=None, ensure_ascii=False, sort_keys=False, separators=(',', ':'))
+}
 
-def write_json(content, file_path, sort_keys=False, converters=None, b_use_suggested_converter=False):
+
+def write_json(content, file_path, converters=None, b_use_suggested_converter=False, output_format="pretty_printed"):
     """
         写入 json file
 
@@ -13,7 +18,6 @@ def write_json(content, file_path, sort_keys=False, converters=None, b_use_sugge
             content:                    待写入内容
             file_path:                  <path or None> 写入路径
                                             当设置为 None 时，将直接把（经converters处理后的）待写入内容作为结果返回，而不进行实际的写入
-            sort_keys
             converters:                 <list of converters> 对写入内容中每个节点的处理方式
                                             转换器 converter 应该是一个形如 def(x): ... ; return x 的函数，具体可以参考
                                             json_.converter 中已实现的转换器
@@ -22,8 +26,27 @@ def write_json(content, file_path, sort_keys=False, converters=None, b_use_sugge
                                             可以避免因 json 的读取/写入而丢失部分信息。
                                             默认为 False。
                     注意：当 converters 非 None，此参数失效，以 converters 中的具体设置为准
+            output_format:              <str/dict/tuple> json的输出格式
+                                            对于 str 目前支持以下取值：
+                                                - "pretty_printed":     通过添加大量的空格和换行符来格式化输出，使输出更易读
+                                                - "minified":           删除所有空格和换行符，使输出更紧凑
+                                            默认为 pretty_printed。
+                                            对于 dict，将允许使用更加细致的格式设定，比如：
+                                                {"indent": 2, ensure_ascii=True}
+                                            如果需要基于已有格式进行微调可以使用以下方式:
+                                                ("pretty_printed", {"indent": 2, ensure_ascii=True})
     """
+    global format_s
     assert isinstance(file_path, (str, type(None)))
+    if isinstance(output_format, (str,)):
+        output_format = format_s[output_format]
+    elif isinstance(output_format, (tuple,)):
+        output_format = format_s[output_format[0]]
+        output_format.update(output_format[1])
+    elif isinstance(output_format, (dict,)):
+        pass
+    else:
+        raise ValueError(f'Unsupported output_format: {output_format}.')
 
     if converters is None and b_use_suggested_converter:
         converters = [escape_tuple_and_set, escape_non_str_dict_key]
@@ -35,7 +58,7 @@ def write_json(content, file_path, sort_keys=False, converters=None, b_use_sugge
                            converter=lambda _, x: converter(x),
                            b_traverse_matched_element=True)[0]
 
-    content = json.dumps(content, indent=4, ensure_ascii=False, sort_keys=sort_keys)
+    content = json.dumps(content, **output_format)
 
     if file_path is not None:
         file_path = os.path.abspath(os.path.expanduser(file_path))
@@ -44,3 +67,13 @@ def write_json(content, file_path, sort_keys=False, converters=None, b_use_sugge
             f.write(content)
     else:
         return content
+
+
+if __name__ == "__main__":
+    a = {'rect': {'l:eft': [0, 1, 2], 'top': 67, 'right': 286, 'bottom': 332}}
+    res_0 = write_json(a, file_path=None, output_format="pretty_printed")
+    print(res_0)
+    print(len(res_0))
+    res_1 = write_json(a, file_path=None, output_format="minified")
+    print(res_1)
+    print(len(res_1))

kevin_toolbox/env_info/__init__.py

@@ -1 +1,2 @@
-
+from .check_version_and_update import check_version_and_update
+from .check_validity_and_uninstall import check_validity_and_uninstall