kevin-toolbox-dev 1.4.6__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.6 → kevin-toolbox-dev-1.4.7}/kevin_toolbox/__init__.py

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

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.6 → 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.6 → kevin-toolbox-dev-1.4.7}/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-dev-1.4.6 → kevin-toolbox-dev-1.4.7}/kevin_toolbox/nested_dict_list/serializer/backends/_json_.py

@@ -35,8 +35,8 @@ class Json_(Backend_Base):
         """
         if id(var) != self.w_cache_s["id_"]:
             try:
-                self.w_cache_s["content"] = json_.write(content=var, file_path=None, sort_keys=False,
-                                                        b_use_suggested_converter=True)
+                self.w_cache_s["content"] = json_.write(content=var, file_path=None, b_use_suggested_converter=True,
+                                                        output_format=kwargs.get("output_format", "pretty_printed"))
             except:
                 self.w_cache_s["content"], self.w_cache_s["id_"] = None, None
                 self.w_cache_s["able"] = False

{kevin-toolbox-dev-1.4.6 → kevin-toolbox-dev-1.4.7}/kevin_toolbox/patches/for_matplotlib/common_charts/plot_lines.py

@@ -5,7 +5,7 @@ from kevin_toolbox.patches.for_os.path import replace_illegal_chars
 from kevin_toolbox.patches.for_matplotlib.color import generate_color_list
 
 
-def plot_lines(data_s, title, x_name, output_dir=None, **kwargs):
+def plot_lines(data_s, title, x_name, x_ticklabels_name=None, output_dir=None, **kwargs):
     data_s = copy.copy(data_s)
     line_nums = len(data_s) - 1
     paras = {
@@ -23,6 +23,10 @@ def plot_lines(data_s, title, x_name, output_dir=None, **kwargs):
     plt.clf()
     #
     x_all_ls = data_s.pop(x_name)
+    if x_ticklabels_name is not None:
+        x_ticklabels = data_s.pop(x_ticklabels_name)
+        assert len(x_all_ls) == len(x_ticklabels)
+        plt.xticks(x_all_ls, x_ticklabels)
     data_s, temp = dict(), data_s
     for k, v_ls in temp.items():
         y_ls, x_ls = [], []