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

kevin_toolbox/env_info/variable_/env_vars_parser.py

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

kevin_toolbox/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/nested_dict_list/serializer/variable.py

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

kevin_toolbox/nested_dict_list/serializer/write.py

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

kevin_toolbox/network/__init__.py

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

kevin_toolbox/network/download_file.py

@@ -0,0 +1,120 @@
+import os
+import time
+from tqdm import tqdm
+from kevin_toolbox.network import fetch_metadata, fetch_content, get_response
+from kevin_toolbox.patches.for_os.path import replace_illegal_chars
+from kevin_toolbox.patches import for_os
+from kevin_toolbox.nested_dict_list import get_hash
+
+default_option_func_s = {
+    "hash_name": lambda url, _, option_s: {"hash_name": get_hash(option_s["name"], length=12)},
+    "hash_url": lambda url, _, option_s: {"hash_url": get_hash(url, length=12)},
+    "timestamp": lambda *arg, **kwargs: {"timestamp": f'{time.time()}'},
+    "legalized_name": lambda url, _, option_s: {
+        "legalized_name": replace_illegal_chars(file_name=option_s["name"], b_is_path=False)}
+}
+
+
+def download_file(
+        output_dir, url=None, response=None, chunk_size=1024 * 10,
+        file_name=None, file_name_format="{legalized_name:.100}{suffix}", format_option_generate_func_ls=None,
+        b_allow_overwrite=False, b_display_progress=False, **kwargs
+):
+    """
+        下载文件
+            支持以下高级功能：
+                1. 自动识别文件类型并命名。
+                2. 多次重试。
+                3. TODO:断点续传（待实现）。
+
+        参数：
+            output_dir:             <path> 文件保存的目录
+            url:                    <str> 下载的 URL 地址。
+            response:               响应。
+                        以上两个参数只需要指定其一即可，建议使用后者。
+            chunk_size:             <int> 采用分块下载时，块的大小
+                                        默认为 1024 * 10
+            file_name:              <str> 文件名
+                                        默认为 None，此时将根据 file_name_format 自动生成名字。
+            file_name_format:       <str> 保存的文件的命名方式。
+                                        基本结构为：  '{<part_0>}...{<part_1>}...'
+                                        其中 {} 内将根据 part 指定的选项进行自动填充。目前支持以下几种选项：
+                                            - "name"            文件名（不含后缀）。
+                                            - "suffix"          后缀。
+                                            - "timestamp"       下载的时间戳。
+                                            - "hash_name"       文件名的hash值。
+                                            - "legalized_name"  经过合法化处理的文件名（对其中特殊符号进行了替换）。
+                                            - "hash_url"        url的hash值。
+                                        ！！注意：
+                                            "name" 该选项由于其可能含有 : 和 / 等特殊符号，当以其作为文件名时，可能会引发错误。
+                                                因此对于 windows 用户，请慎重使用该选项，对于 mac 和 linux 用户，同样也不建议使用该选项。
+                                                相较而言，"legalized_name" 是一个更好的选择。
+                                            "hash_name" 和 "hash_url" 有极低但非0的可能会发生 hash 碰撞。
+                                        综合而言：
+                                            建议使用 "legalized_name" 和 "suffix" 以及 "timestamp" 的组合。
+                                        高级设置：
+                                            1. 如果想限制文件名中某部分的长度（避免文件名过长在某些系统下引发报错），应该如何做？
+                                                本命名方式兼容 str.format() 语法，比如你可以通过 {name:.10} 来限制名字的长度不大于10个字符。
+                                            2. 如果已有的选项无法满足你的需求，如何新增选项？
+                                                本函数支持通过设置 format_option_generate_func_ls 来补充或者覆盖默认选项。
+                                        默认值为：
+                                            '{legalized_name:.100}{suffix}'
+            format_option_generate_func_ls: <list of callable> 函数列表，将使用这些函数的结果来对 file_name_format 中的选项进行补充或者覆盖。
+                                        函数需要接受 url, response, option_s（已有的选项键值对） 三个参数，并返回一个包含选项名和选项值的 dict。
+                                        默认为 None
+            b_allow_overwrite:          <boolean> 是否允许覆盖已有文件。
+            b_display_progress:         <boolean> 显示进度条。
+
+
+        返回：
+          文件完整路径（下载成功）或空字符串（失败）
+    """
+    global default_option_func_s
+    assert url is not None or response is not None
+    if url is not None:
+        response = response or get_response(url=url, **kwargs)
+    assert response is not None
+    output_dir = os.path.expanduser(output_dir)
+    #
+    metadata_s = fetch_metadata(url=url, response=response, default_name="", default_suffix="")
+    if file_name is None:
+        option_s = metadata_s.copy()
+        for k, func in default_option_func_s.items():
+            if k in file_name_format:
+                option_s.update(func(url, response, option_s))
+        if isinstance(format_option_generate_func_ls, (list, tuple,)):
+            for func in format_option_generate_func_ls:
+                assert callable(func)
+                option_s.update(func(url, response, option_s))
+        file_name = file_name_format.format(**option_s)
+    #
+    os.makedirs(output_dir, exist_ok=True)
+    #
+    file_path = os.path.join(output_dir, file_name)
+    if os.path.exists(file_path):
+        if b_allow_overwrite:
+            for_os.remove(path=file_path, ignore_errors=True)
+        else:
+            raise FileExistsError(f"target {file_path} already exists")
+
+    if metadata_s["content_length"] and b_display_progress:
+        pbar = tqdm(total=metadata_s["content_length"], unit="B", unit_scale=True, desc="下载进度")
+    else:
+        pbar = None
+
+    with open(file_path, "wb") as f:
+        for chunk in fetch_content(response=response, chunk_size=chunk_size):
+            if chunk:
+                f.write(chunk)
+                if pbar is not None:
+                    pbar.update(len(chunk))
+
+    return file_path
+
+
+# 示例用法
+if __name__ == "__main__":
+    url_ = "https://i.pinimg.com/736x/28/6a/b1/286ab1eb816dc59a1c72374c75645d80.jpg"
+    output_dir = r'./temp/123'
+    downloaded_file = download_file(url=url_, output_dir=output_dir, file_name="233.jpg", b_allow_overwrite=True,
+                                    b_display_progress=True, chunk_size=100)

kevin_toolbox/network/fetch_content.py

@@ -0,0 +1,55 @@
+import warnings
+from kevin_toolbox.network import get_response
+
+
+def fetch_content(url=None, response=None, decoding=None, chunk_size=None, **kwargs):
+    """
+        从 URL/response 中获取内容
+
+        参数：
+            url:                <str> 请求的 URL 地址。
+            response:           响应。
+                        以上两个参数只需要指定其一即可，建议使用后者。
+            decoding:           <str> 响应内容的解码方式
+                                    默认为 None，返回原始的字节流。
+                                    一些常用的可选值：
+                                        "utf-8"
+            chunk_size:         <int> 采用分块方式读取内容时，块的大小
+                                    默认为 None，此时不使用分块读取，而直接读取所有内容
+                        注意！当 chunk_size 非 None 时，decoding 将失效
+
+        返回：
+            当 chunk_size 为 None 时：
+                str: 请求成功后的响应内容。如果 decoding 为 None，则返回 bytes 类型数据。
+            当 chunk_size 非 None 时：
+                读取内容的生成器。
+    """
+    assert url is not None or response is not None
+    if url is not None:
+        response = response or get_response(url=url, **kwargs)
+    assert response is not None
+
+    if chunk_size is None:
+        content = response.data
+        if decoding:
+            content = content.decode(decoding)
+        return content
+    else:
+        if decoding:
+            warnings.warn(f'当 chunk_size 非 None 时，decoding 参数将失效。')
+        return __generator(response, chunk_size)
+
+
+def __generator(response, chunk_size):
+    while True:
+        chunk = response.read(chunk_size)
+        if not chunk:
+            break
+        yield chunk
+
+
+if __name__ == "__main__":
+    url_ = "https://i.pinimg.com/736x/28/6a/b1/286ab1eb816dc59a1c72374c75645d80.jpg"  # "https://www.google.com/"
+    print(len(fetch_content(url=url_, decoding=None)))
+    for i, j in enumerate(fetch_content(url=url_, chunk_size=50000)):
+        print(i, len(j))

kevin_toolbox/network/fetch_metadata.py

@@ -0,0 +1,64 @@
+import os
+import re
+import time
+import mimetypes
+from urllib.parse import quote
+from urllib.parse import urlsplit, unquote
+from kevin_toolbox.network import get_response
+
+
+def fetch_metadata(url=None, response=None, default_suffix=".bin", default_name=None, **kwargs):
+    """
+        从 URL/response 中获取文件名、后缀（扩展名）、大小等元信息
+
+        参数：
+            url:                <str> 请求的 URL 地址。
+            response:           响应。
+                        以上两个参数建议同时指定。
+            default_suffix:     <str> 默认后缀。
+            default_name:       <str> 默认文件名。
+                                    默认为 None，表示使用当前时间戳作为默认文件名。
+                    只有从 URL/response 中无法获取出 suffix 和 name 时才会使用上面的默认值作为填充
+
+        返回：
+            dict with keys ['content_length', 'content_type', 'content_disp', 'suffix', 'name']
+    """
+    assert url is not None or response is not None
+    if url is not None:
+        response = response or get_response(url=url, **kwargs)
+    assert response is not None
+    default_name = f'{time.time()}' if default_name is None else default_name
+
+    metadata_s = {"content_length": None, "content_type": None, "content_disp": None, "suffix": None, "name": None}
+    name, suffix = None, None
+    # 尝试直接从url中获取文件名和后缀
+    if url is not None:
+        url = quote(url, safe='/:?=&')
+        basename = unquote(os.path.basename(urlsplit(url).path))
+        name, suffix = os.path.splitext(basename)
+    # 尝试从更加可信的响应头中获取文件名和后缀
+    content_length = response.headers.get("Content-Length", None)
+    metadata_s["content_length"] = int(content_length) if content_length and content_length.isdigit() else None
+    #
+    content_type = response.headers.get("Content-Type", None)
+    metadata_s["content_type"] = content_type
+    if content_type:
+        suffix = mimetypes.guess_extension(content_type.split(";")[0].strip()) or suffix
+    #
+    content_disp = response.headers.get("Content-Disposition", None)
+    metadata_s["content_disp"] = content_disp
+    if content_disp:
+        temp_ls = re.findall('filename="([^"]+)"', content_disp)
+        if temp_ls:
+            name, temp = os.path.splitext(temp_ls[0])
+            suffix = temp or suffix
+    metadata_s["name"] = name or default_name
+    metadata_s["suffix"] = suffix or default_suffix
+
+    return metadata_s
+
+
+# 示例用法
+if __name__ == "__main__":
+    url_ = "https://i.pinimg.com/736x/28/6a/b1/286ab1eb816dc59a1c72374c75645d80.jpg"  # "https://www.google.com/"
+    print(fetch_metadata(url=url_))

kevin_toolbox/network/get_response.py

@@ -0,0 +1,50 @@
+import urllib3
+from urllib.parse import quote
+from kevin_toolbox.computer_science.algorithm.decorator import retry
+from kevin_toolbox.network.variable import DEFAULT_HEADERS
+
+# 全局 PoolManager 实例，设置 cert_reqs='CERT_NONE' 可关闭 SSL 证书验证
+http = urllib3.PoolManager(cert_reqs='CERT_NONE')
+
+
+def get_response(url, data=None, headers=None, method=None, retries=3, delay=0.5, b_verbose=False, stream=True,
+                 **kwargs):
+    """
+        获取 url 的响应
+
+        参数：
+            url:                <str> 请求的 URL 地址。
+            data:               <bytes, optional> 请求发送的数据，如果需要传递数据，必须是字节类型。
+            headers:            <dict> 请求头字典。
+                                    默认为 DEFAULT_HEADERS。
+            method:             <str> HTTP 请求方法，如 "GET", "POST" 等。
+            retries:            <int> 重试次数
+                                    默认重试3次
+            delay:              <int/float> 每次重试前等待的秒数。
+                                    默认0.5秒
+            b_verbose:          <boolean> 进行多次重试时是否打印详细日志信息。
+                                    默认为 False。
+
+        返回：
+            响应。 urllib3.response.HTTPResponse object
+    """
+    headers = headers or DEFAULT_HEADERS
+
+    url = quote(url, safe='/:?=&')
+    worker = retry(retries=retries, delay=delay, logger="default" if b_verbose else None)(func=__worker)
+    response = worker(url, data, headers, method, stream)
+    return response
+
+
+def __worker(url, data, headers, method, stream):
+    method = method if method is not None else "GET"
+    response = http.request(method, url, body=data, headers=headers, preload_content=not stream)
+    if response.status >= 400:
+        raise Exception(f"HTTP 请求失败，状态码：{response.status}")
+    return response
+
+
+if __name__ == "__main__":
+    url_ = "https://i.pinimg.com/736x/28/6a/b1/286ab1eb816dc59a1c72374c75645d80.jpg"  # "https://www.google.com/"
+    a = get_response(url=url_, b_verbose=True)
+    print(a)

kevin_toolbox/network/variable.py

@@ -0,0 +1,6 @@
+DEFAULT_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+                  "(KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36",
+    "Upgrade-Insecure-Requests": "1",
+    # "Cookie": ''
+}

kevin_toolbox/patches/for_logging/build_logger.py

@@ -49,7 +49,7 @@ def build_logger(name, handler_ls, level=logging.DEBUG,
             # 输出到控制台
             handler = logging.StreamHandler()
         else:
-            raise ValueError(f'unexpected target {target}')
+            raise ValueError(f'unexpected target {details["target"]}')
         handler.setLevel(details.get("level", level))
         handler.setFormatter(logging.Formatter(details.get("formatter", formatter)))
         # 添加到logger中

kevin_toolbox/patches/for_matplotlib/common_charts/__init__.py

@@ -1,6 +1,51 @@
+# 在非 windows 系统下，尝试自动下载中文字体，并尝试自动设置字体
+import sys
+
+if not sys.platform.startswith("win"):
+    import os
+    from kevin_toolbox.env_info.variable_ import env_vars_parser
+
+    font_setting_s = dict(
+        b_auto_download=True,
+        download_url="https://drive.usercontent.google.com/download?id=1wd-a4-AwAXkr7mHmB9BAIcGpAcqMrbqg&export=download&authuser=0",
+        save_path="~/.kvt_data/fonts/SimHei.ttf"
+    )
+    font_setting_s.update()
+    for k, v in list(font_setting_s.items()):
+        font_setting_s[k] = env_vars_parser.parse(
+            text=f"${{KVT_PATCHES:for_matplotlib:common_charts:font_settings:for_non-windows-platform:{k}}}",
+            default=v
+        )
+    save_path = os.path.expanduser(font_setting_s["save_path"])
+
+    if font_setting_s["b_auto_download"] and not os.path.isfile(save_path):
+        from kevin_toolbox.network import download_file
+
+        print(f'检测到当前系统非 Windows 系统，尝试自动下载中文字体...')
+        download_file(
+            output_dir=os.path.dirname(save_path),
+            file_name=os.path.basename(save_path),
+            url=font_setting_s["download_url"],
+            b_display_progress=True
+        )
+
+    if os.path.isfile(save_path):
+        import matplotlib.font_manager as fm
+        import matplotlib.pyplot as plt
+
+        # 注册字体
+        fm.fontManager.addfont(save_path)
+        # 获取字体名称
+        font_name = fm.FontProperties(fname=save_path).get_name()
+
+        # 全局设置默认字体
+        plt.rcParams['font.family'] = font_name
+        plt.rcParams['axes.unicode_minus'] = False  # 解决负号 '-' 显示为方块的问题
+
 from .plot_lines import plot_lines
 from .plot_scatters import plot_scatters
 from .plot_distribution import plot_distribution
 from .plot_bars import plot_bars
 from .plot_scatters_matrix import plot_scatters_matrix
 from .plot_confusion_matrix import plot_confusion_matrix
+from .plot_from_record import plot_from_record

kevin_toolbox/patches/for_matplotlib/common_charts/plot_bars.py

@@ -1,20 +1,62 @@
-import os
-import copy
-from kevin_toolbox.computer_science.algorithm import for_seq
 import matplotlib.pyplot as plt
-from kevin_toolbox.patches.for_os.path import replace_illegal_chars
+from kevin_toolbox.computer_science.algorithm import for_seq
+from kevin_toolbox.patches.for_matplotlib.common_charts.utils import save_plot, save_record, get_output_path
+from kevin_toolbox.patches.for_matplotlib.variable import COMMON_CHARTS
+
+__name = ":common_charts:plot_bars"
+
 
-# TODO 在 linux 系统下遇到中文时，尝试自动下载中文字体，并尝试自动设置字体
-# font_path = os.path.join(root_dir, "utils/SimHei.ttf")
-# font_name = FontProperties(fname=font_path)
+@COMMON_CHARTS.register(name=__name)
+def plot_bars(data_s, title, x_name, output_dir=None, output_path=None, **kwargs):
+    """
+        绘制条形图
 
+        参数：
+            data_s:             <dict> 数据。
+                                    形如 {<data_name>: <data list>, ...} 的字典
+            title:              <str> 绘图标题。
+            x_name:             <str> 以哪个 data_name 作为 x 轴。
+                                    其余数据视为需要被绘制的数据点。
+                    例子： data_s={"step":[...], "acc_top1":[...], "acc_top3":[...]}
+                        当 x_name="step" 时，将会以 step 为 x 轴绘制 acc_top1 和 acc_top3 的 bar 图。
+            x_label:            <str> x 轴的标签名称。
+                                    默认与指定的 x_name 相同。
+            y_label:            <str> y 轴的标签名称。
+                                    默认为 "value"。
+            output_dir:         <str or None> 图片输出目录。
+            output_path:        <str or None> 图片输出路径。
+                        以上两个只需指定一个即可，同时指定时以后者为准。
+                        当只有 output_dir 被指定时，将会以 title 作为图片名。
+                        若同时不指定，则直接调用 plt.show() 显示图像，而不进行保存。
+                        在保存为文件时，若文件名中存在路径不适宜的非法字符将会被进行替换。
 
-def plot_bars(data_s, title, x_name, y_label=None, output_dir=None, **kwargs):
-    data_s = copy.deepcopy(data_s)
+        其他可选参数：
+            dpi:                <int> 保存图像的分辨率。
+                                    默认为 200。
+            suffix:             <str> 图片保存后缀。
+                                    目前支持的取值有 ".png", ".jpg", ".bmp"，默认为第一个。
+            b_generate_record:  <boolean> 是否保存函数参数为档案。
+                                    默认为 False，当设置为 True 时将会把函数参数保存成 [output_path].record.tar。
+                                    后续可以使用 plot_from_record() 函数或者 Serializer_for_Registry_Execution 读取该档案，并进行修改和重新绘制。
+                                    该参数仅在 output_dir 和 output_path 非 None 时起效。
+
+        返回值：
+            若 output_dir 非 None，则返回图像保存的文件路径。
+    """
+    assert x_name in data_s and len(data_s) >= 2
     paras = {
-        "dpi": 200
+        "x_label": f'{x_name}',
+        "y_label": "value",
+        "dpi": 200,
+        "suffix": ".png",
+        "b_generate_record": False
     }
     paras.update(kwargs)
+    #
+    _output_path = get_output_path(output_path=output_path, output_dir=output_dir, title=title, **kwargs)
+    save_record(_func=plot_bars, _name=__name, _output_path=_output_path if paras["b_generate_record"] else None,
+                **paras)
+    data_s = data_s.copy()
 
     plt.clf()
     #
@@ -26,29 +68,28 @@ def plot_bars(data_s, title, x_name, y_label=None, output_dir=None, **kwargs):
         else:
             plt.bar([j + 0.1 for j in range(len(x_all_ls))], y_ls, width=0.2, align='center', label=k)
 
-    plt.xlabel(f'{x_name}')
-    plt.ylabel(f'{y_label if y_label else "value"}')
+    plt.xlabel(paras["x_label"])
+    plt.ylabel(paras["y_label"])
     temp = for_seq.flatten_list([list(i) for i in data_s.values()])
     y_min, y_max = min(temp), max(temp)
     plt.ylim(max(min(y_min, 0), y_min - (y_max - y_min) * 0.2), y_max + (y_max - y_min) * 0.1)
-    plt.xticks(list(range(len(x_all_ls))), labels=x_all_ls)  # , fontproperties=font_name
+    plt.xticks(list(range(len(x_all_ls))), labels=x_all_ls)
     plt.title(f'{title}')
     # 显示图例
     plt.legend()
 
-    if output_dir is None:
-        plt.show()
-        return None
-    else:
-        os.makedirs(output_dir, exist_ok=True)
-        output_path = os.path.join(output_dir, f'{replace_illegal_chars(title)}.png')
-        plt.savefig(output_path, dpi=paras["dpi"])
-        return output_path
+    save_plot(plt=plt, output_path=_output_path, dpi=paras["dpi"], suffix=paras["suffix"])
+
+    return _output_path
 
 
 if __name__ == '__main__':
+    import os
+
     plot_bars(data_s={
         'a': [1.5, 2, 3, 4, 5],
         'b': [5, 4, 3, 2, 1],
         'c': [1, 2, 3, 4, 5]},
-        title='test', x_name='a', output_dir=os.path.join(os.path.dirname(__file__), "temp"))
+        title='test_plot_bars', x_name='a', output_dir=os.path.join(os.path.dirname(__file__), "temp"),
+        b_generate_record=True
+    )