kevin-toolbox-dev 1.4.6__py3-none-any.whl → 1.4.8__py3-none-any.whl

kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.4.6"
+__version__ = "1.4.8"
 
 
 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 1753280251 --verbose 0'
+    f'--expiration_timestamp 1756803931 --verbose 0'
 )

kevin_toolbox/{developing → 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/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/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/algorithm/registration/__init__.py

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

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/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/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/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))