kevin-toolbox-dev 1.3.9__py3-none-any.whl → 1.4.1__py3-none-any.whl

kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.3.9"
+__version__ = "1.4.1"
 
 
 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 1739091416 --verbose 0'
+    f'--expiration_timestamp 1742651885 --verbose 0'
 )

kevin_toolbox/data_flow/file/markdown/__init__.py

@@ -1,6 +1,6 @@
-from .generate_link import generate_link
 from .generate_list import generate_list
-from .generate_table import generate_table
-from .parse_table import parse_table
-from .find_tables import find_tables
-from .save_images_in_ndl import save_images_in_ndl
+from .table import generate_table
+from .link import generate_link
+from .utils import save_images_in_ndl
+#
+from . import link, table

kevin_toolbox/data_flow/file/markdown/link/__init__.py

@@ -0,0 +1,2 @@
+from .find_links import find_links
+from .generate_link import generate_link

kevin_toolbox/data_flow/file/markdown/link/find_links.py

@@ -0,0 +1,84 @@
+import re
+
+
+def find_links(text, b_compact_format=True, type_ls=None):
+    """
+        查找文本中的链接
+
+        参数:
+            text:               <str> 文本
+            b_compact_format:   <bool> 是否只返回 link 部分
+                                    默认为 True，此时返回 link_ls，其中每个元素是一个链接
+                                    当设置为 False，此时返回 (link_ls, part_slices_ls, link_idx_ls)，
+                                        其中 part_slices_ls 是链接和链接前后文本在 text 中对应的 slice，
+                                        而 link_idx_ls 指出了 part_slices_ls 中第几个元素对应的是链接，
+                                        link_idx_ls 与 link_ls 依次对应。
+            type_ls:              <list of str> 找出哪种类型的链接
+                                    默认为 None，此时表示找出所有类型的链接。
+                                    支持以下取值：
+                                        "url", "image"
+    """
+
+    matches = re.finditer(r'\[(.*?)\]\((.*?)(?:\s*["\'](.*?)["\'])?\)', text, re.DOTALL)
+
+    link_ls = []
+    part_slices_ls = []
+    link_idx_ls = []
+    start = 0
+    for match in matches:
+        link_start, link_end = match.start(), match.end()
+        #
+        if text[link_start - 1] == "!":
+            type_ = "image"
+            link_start -= 1
+        else:
+            type_ = "url"
+        #
+        if type_ls is not None and type_ not in type_ls:
+            continue
+        #
+        part_slices_ls.append([start, link_start])
+        # 图片本身
+        link_s = dict(
+            type_=type_,
+            name=match.group(1),
+            target=match.group(2),
+            title=match.group(3) if match.group(3) else None
+        )
+        link_idx_ls.append(len(part_slices_ls))
+        link_ls.append(link_s)
+        part_slices_ls.append([link_start, link_end])
+        # 更新起始位置
+        start = match.end()
+
+    last = text[start:]
+    if last:
+        part_slices_ls.append([start, len(text)])
+
+    if b_compact_format:
+        return link_ls
+    else:
+        return link_ls, part_slices_ls, link_idx_ls
+
+
+if __name__ == "__main__":
+    markdown_text = """
+    Here is an image:
+    ![This is a picture of a cat](http://example.com/cat.jpg "A cute cat")
+    And another one:
+    ![This is a picture of a dog](http://example.com/dog.jpg 'A cute dog')
+    And one without alt text:
+    [](http://example.com/placeholder.jpg)
+    And one without title:
+    ![<image_name>](<image_path>)
+    """
+    from kevin_toolbox.data_flow.file import markdown
+
+    print(markdown.generate_list(find_links(text=markdown_text, b_compact_format=True)))
+
+    link_ls_, part_slices_ls_, link_idx_ls_ = find_links(text=markdown_text, b_compact_format=False, type_ls=["url"])
+
+    print(link_ls_)
+    for part_slices in part_slices_ls_:
+        print(part_slices)
+        print(markdown_text[part_slices[0]:part_slices[1]])

kevin_toolbox/data_flow/file/markdown/link/generate_link.py

@@ -0,0 +1,10 @@
+def generate_link(name, target, title=None, type_="url"):
+    assert type_ in ["url", "image"]
+    if title is not None:
+        target = f'{target} "{title}"'
+    return f'{"!" if type_ == "image" else ""}[{name}]({target})'
+
+
+if __name__ == '__main__':
+    print(generate_link(name=444, target="233", type_="url"))
+    print(generate_link(name=444, target="233", type_="image", title="233"))

kevin_toolbox/data_flow/file/markdown/table/__init__.py

@@ -0,0 +1,6 @@
+from .variable import Table_Format
+from .get_format import get_format
+from .padding_misaligned_values import padding_misaligned_values
+from .convert_format import convert_format
+from .find_tables import find_tables
+from .generate_table import generate_table

kevin_toolbox/data_flow/file/markdown/table/convert/__init__.py

@@ -0,0 +1,2 @@
+from .matrix_to_complete import matrix_to_complete
+from .complete_to_matrix import complete_to_matrix

kevin_toolbox/data_flow/file/markdown/table/convert/complete_to_matrix.py

@@ -0,0 +1,106 @@
+from kevin_toolbox.math.utils import split_integer_most_evenly
+from kevin_toolbox.data_flow.file.markdown.table import Table_Format, get_format, padding_misaligned_values
+
+
+def complete_to_matrix(content_s, orientation="vertical", chunk_nums=None, chunk_size=None):
+    """
+        生成表格
+
+        参数：
+            content_s:              <dict> 内容
+                                        目前支持 Table_Format 中的两种输入模式：
+                                            1.简易模式：
+                                                content_s = {<title>: <list of value>, ...}
+                                                此时键作为标题，值作为标题下的一系列值。
+                                                由于字典的无序性，此时标题的顺序是不能保证的，若要额外指定顺序，请使用下面的 完整模式。
+                                            2. 完整模式:
+                                                content_s = {<index>: {"title": <title>,"values":<list of value>}, ...}
+                                                此时将取第 <index> 个 "title" 的值来作为第 <index> 个标题的值。values 同理。
+                                                该模式允许缺省某些 <index>，此时这些 <index> 对应的行/列将全部置空。
+            orientation:            <str> 表格的方向
+                                        支持以下值：
+                                            "vertical" / "v":       纵向排列，亦即标题在第一行
+                                            "horizontal" / "h":     横向排列，亦即标题在第一列
+            chunk_nums:             <int> 将表格平均分割为多少份进行并列显示。
+            chunk_size:             <int> 将表格按照最大长度进行分割，然后并列显示。
+                注意：以上两个参数只能设置一个，同时设置时将报错
+    """
+    # 检验参数
+    assert chunk_nums is None or 1 <= chunk_nums
+    assert chunk_size is None or 1 <= chunk_size
+    assert orientation in ["vertical", "horizontal", "h", "v"]
+    assert get_format(content_s) is Table_Format.COMPLETE_DICT
+
+    # 当不同标题下的 values 的长度不相等时，先使用 padding_misaligned_values() 来进行对齐
+    content_s = padding_misaligned_values(content_s=content_s, padding_value="")
+    max_length = len(list(content_s.values())[0]["values"])
+
+    # 补充缺省的 title
+    for i in range(max(content_s.keys()) + 1):
+        if i not in content_s:
+            content_s[i] = {"title": "", "values": [""] * max_length}
+    # 按照 chunk_nums 或者 chunk_size 对表格进行分割
+    if chunk_nums is not None or chunk_size is not None:
+        if chunk_nums is not None:
+            split_len_ls = split_integer_most_evenly(x=max_length, group_nums=chunk_nums)
+        else:
+            split_len_ls = [chunk_size] * (max_length // chunk_size)
+            if max_length % chunk_size != 0:
+                split_len_ls += [max_length % chunk_size]
+        max_length = max(split_len_ls)
+        temp = dict()
+        beg = 0
+        for i, new_length in enumerate(split_len_ls):
+            end = beg + new_length
+            temp.update({k + i * len(content_s): {"title": v["title"],
+                                                  "values": v["values"][beg:end] + [""] * (max_length - new_length)} for
+                         k, v in content_s.items()})
+            beg = end
+        content_s = temp
+
+    # 转换
+    row_ls = []
+    if orientation in ["vertical", "v"]:
+        row_ls.append([content_s[i]["title"] for i in range(len(content_s))])
+        for row in zip(*[content_s[i]["values"] for i in range(len(content_s))]):
+            row_ls.append(row)
+    else:
+        for i in range(len(content_s)):
+            row_ls.append([content_s[i]["title"]] + content_s[i]["values"])
+
+    return dict(matrix=row_ls, orientation=orientation, chunk_size=chunk_size, chunk_nums=chunk_nums,
+                b_remove_empty_lines=chunk_size is not None or chunk_nums is not None)
+
+
+if __name__ == '__main__':
+    from kevin_toolbox.data_flow.file.markdown.table import convert_format
+
+    content_s = complete_to_matrix(
+        content_s=convert_format(
+            content_s={'y/n': ['False', 'False', 'False', 'False', 'False', 'True', 'True', 'True', 'True', 'True'],
+                       'a': ['5', '8', '7', '6', '9', '2', '1', '4', '0', '3'],
+                       'b': ['', '', '', '', '', '6', '4', ':', '2', '8']},
+            output_format=Table_Format.COMPLETE_DICT
+        ),
+        orientation="v", chunk_size=4
+    )
+
+
+    def _show_table(row_ls):
+        """
+            生成表格文本
+
+            参数：
+                row_ls:                 <list of row>
+        """
+        table = ""
+        for idx, row in enumerate(row_ls):
+            row = [f'{i}' for i in row]
+            table += "| " + " | ".join(row) + " |\n"
+            if idx == 0:
+                table += "| " + " | ".join(["---"] * len(row)) + " |\n"
+        return table
+
+
+    doc = _show_table(content_s["matrix"])
+    print(doc)

kevin_toolbox/data_flow/file/markdown/{parse_table.py → table/convert/matrix_to_complete.py}

@@ -1,17 +1,9 @@
-import re
-from typing import Union
-from kevin_toolbox.data_flow.file.markdown.variable import Table_Format
-
-
-def parse_table(raw_table, output_format: Union[Table_Format, str] = Table_Format.COMPLETE_DICT, orientation="vertical",
-                chunk_size=None, chunk_nums=None, b_remove_empty_lines=False, f_gen_order_of_values=None):
+def matrix_to_complete(matrix, orientation, chunk_size=None, chunk_nums=None, b_remove_empty_lines=False):
     """
-        将二维数组形式的表格（比如find_tables()的返回列表的元素），解析成指定的格式
+        将二维数组形式的 MATRIX 格式（比如find_tables()的返回列表的元素），转换成 COMPLETE_DICT 格式
 
         参数：
-            raw_table:                  <list of list> 二维数组形式的表格
-            output_format:              <Table_Format or str> 目标格式
-                                            具体可以参考 Table_Format 的介绍
+            matrix:                     <list of row> 二维数组形式的表格
             orientation:                <str> 解释表格时取哪个方向
                                             支持以下值：
                                             "vertical" / "v":       将第一行作为标题
@@ -22,35 +14,37 @@ def parse_table(raw_table, output_format: Union[Table_Format, str] = Table_Forma
                 对解释表格无作用。但是当指定该参数时，将视为表格有可能是多个表格并列的情况，因此将尝试根据标题的重复规律，
                 推断出对应的 chunk_nums，并最终将其拆分成多个表格。
             b_remove_empty_lines:       <boolean> 移除空的行、列
-            f_gen_order_of_values:      <callable> 生成values排序顺序的函数
-                                            具体参考 generate_table() 中的对应参数
     """
-    assert isinstance(raw_table, (list, tuple,))
+    # 检验参数
+    assert chunk_nums is None or 1 <= chunk_nums
+    assert chunk_size is None or 1 <= chunk_size
+    assert isinstance(matrix, (list, tuple,))
+    assert orientation in ["vertical", "horizontal", "h", "v"]
 
     # 转换为字典形式
     if orientation not in ["vertical", "v"]:
         # 需要转为垂直方向
-        raw_table = list(zip(*raw_table))
-    r_nums, c_nums = len(raw_table), len(raw_table[0])
+        matrix = list(zip(*matrix))
+    r_nums, c_nums = len(matrix), len(matrix[0])
     if chunk_size is not None:
         assert chunk_size == r_nums - 1, \
             (f'The number of values {r_nums - 1} actually contained in the table '
              f'does not match the specified chunk_size {chunk_size}')
-        chunk_nums = c_nums // _find_shortest_repeating_pattern_size(arr=raw_table[0])
+        chunk_nums = c_nums // _find_shortest_repeating_pattern_size(arr=matrix[0])
     chunk_nums = 1 if chunk_nums is None else chunk_nums
     assert c_nums % chunk_nums == 0, \
         f'The number of headers actually contained in the table does not match the specified chunk_nums, ' \
         f'Expected n*{chunk_nums}, but got {c_nums}'
     # 解释出标题
-    keys = raw_table[0][0:c_nums // chunk_nums]
+    keys = matrix[0][0:c_nums // chunk_nums]
     # 解释出值
     if chunk_nums == 1:
-        values = raw_table[1:]
+        values = matrix[1:]
     else:
         values = []
         for i in range(chunk_nums):
             for j in range(1, r_nums):
-                values.append(raw_table[j][i * len(keys):(i + 1) * len(keys)])
+                values.append(matrix[j][i * len(keys):(i + 1) * len(keys)])
     # 去除空行
     if b_remove_empty_lines:
         values = [line for line in values if any(i != '' for i in line)]
@@ -58,26 +52,6 @@ def parse_table(raw_table, output_format: Union[Table_Format, str] = Table_Forma
     # 去除空列
     if b_remove_empty_lines:
         table_s = {k: v_s for k, v_s in table_s.items() if v_s["title"] != '' and any(i != '' for i in v_s["values"])}
-    # 对值进行排序
-    if callable(f_gen_order_of_values):
-        breakpoint()
-        # 检查是否有重复的 title
-        temp = [v["title"] for v in table_s.values()]
-        assert len(set(temp)) == len(temp), \
-            f'table has duplicate titles, thus cannot be sorted using f_gen_order_of_values'
-        idx_ls = list(range(len(values)))
-        idx_ls.sort(key=lambda x: f_gen_order_of_values({v["title"]: v["values"][x] for v in table_s.values()}))
-        for v in table_s.values():
-            v["values"] = [v["values"][i] for i in idx_ls]
-
-    #
-    if output_format is Table_Format.SIMPLE_DICT:
-        temp = {v_s["title"] for v_s in table_s.values()}
-        if len(temp) != len(set(temp)):
-            raise AssertionError(
-                f'There are columns with the same title in the table, '
-                f'please check the orientation of the table or use output_format="complete_dict"')
-        table_s = {v_s["title"]: v_s["values"] for v_s in table_s.values()}
 
     return table_s
 
@@ -105,6 +79,7 @@ def _find_shortest_repeating_pattern_size(arr):
 
 if __name__ == '__main__':
     from kevin_toolbox.data_flow.file.markdown import find_tables
+
     # # 示例Markdown表格文本
     # file_path = ""
     # with open(file_path, 'r') as f:
@@ -131,5 +106,5 @@ if __name__ == '__main__':
     table_ls = find_tables(text=markdown_text)
 
     # 调用函数并打印结果
-    tables = parse_table(raw_table=table_ls[0], output_format="complete_dict", chunk_nums=3, b_remove_empty_lines=True)
+    tables = matrix_to_complete(matrix=table_ls[0], orientation="v", chunk_nums=3, b_remove_empty_lines=True)
     print(tables)

kevin_toolbox/data_flow/file/markdown/table/convert_format.py

@@ -0,0 +1,51 @@
+from kevin_toolbox.data_flow.file.markdown.table import Table_Format, get_format
+from kevin_toolbox.data_flow.file.markdown.table.convert import matrix_to_complete, complete_to_matrix
+
+
+def simple_to_complete(content_s):
+    return {i: {"title": k, "values": v} for i, (k, v) in enumerate(content_s.items())}
+
+
+def complete_to_simple(content_s):
+    temp = {v_s["title"] for v_s in content_s.values()}
+    if len(temp) != len(set(temp)):
+        raise AssertionError(f'Fail to convert SIMPLE_DICT to COMPLETE_DICT, because there are some duplicate titles.')
+    content_s = {v_s["title"]: v_s["values"] for v_s in content_s.values()}
+    return content_s
+
+
+CONVERT_PROCESS_S = {
+    (Table_Format.COMPLETE_DICT, Table_Format.SIMPLE_DICT): complete_to_simple,  # (from, to): process
+    (Table_Format.COMPLETE_DICT, Table_Format.MATRIX): lambda x: complete_to_matrix(content_s=x),
+    (Table_Format.SIMPLE_DICT, Table_Format.COMPLETE_DICT): simple_to_complete,
+    (Table_Format.SIMPLE_DICT, Table_Format.MATRIX): lambda x: complete_to_matrix(content_s=simple_to_complete(x)),
+    (Table_Format.MATRIX, Table_Format.COMPLETE_DICT): lambda x: matrix_to_complete(**x),
+    (Table_Format.MATRIX, Table_Format.SIMPLE_DICT): lambda x: complete_to_simple(content_s=matrix_to_complete(**x))
+}
+
+
+def convert_format(content_s, output_format, input_format=None):
+    """
+        在各种表格格式之间进行转换
+            ！！注意！！这些转换虽然不会改变表格的内容，但是可能会导致格式信息的丢失
+
+        参数：
+            content_s:          <表格内容>
+            input_format:       <str> 描述输入的格式。
+                                    默认为 None，将根据 content_s 实际格式进行推断。
+            output_format:      <str/list of str> 输出的目标格式。
+                                    当输入是一个 tuple/list 时，将输出其中任一格式，具体规则为：
+                                        - 当 input_format 不在可选的输出格式中时，优先按照第一个输出格式进行转换
+                                        - 当 input_format 在可选的输出格式中时，不进行转换。
+    """
+    if input_format is None:
+        input_format = get_format(content_s=content_s)
+    input_format = Table_Format(input_format)
+    if not isinstance(output_format, (list, tuple,)):
+        output_format = [output_format]
+    output_format = [Table_Format(i) for i in output_format]
+
+    if input_format in output_format:
+        return content_s
+    else:
+        return CONVERT_PROCESS_S[(input_format, output_format[0])](content_s)

kevin_toolbox/data_flow/file/markdown/table/find_tables.py

@@ -0,0 +1,111 @@
+import re
+
+
+def find_tables(text, b_compact_format=True):
+    """
+        查找文本中的表格
+
+        参数:
+            text:               <str> 文本
+            b_compact_format:   <bool> 是否只返回 table 部分
+                                    默认为 True，此时返回 table_ls，其中每个元素是一个 MATRIX 格式的表格
+                                    当设置为 False，此时返回 (table_ls, part_slices_ls, table_idx_ls)，
+                                        其中 part_slices_ls 是表格和表格前后文本在 text 中对应的 slice，
+                                        而 table_idx_ls 指出了 part_slices_ls 中第几个元素对应的是表格，
+                                        table_idx_ls 与 table_ls 依次对应。
+    """
+    text = "\n\n" + text + "\n\n"  # 前后使用哨兵包围
+    matches = re.finditer(r'\n{2,}', text, re.DOTALL)
+
+    table_ls = []
+    part_slices_ls = []
+    table_idx_ls = []
+    #
+    match = next(matches)
+    start, sub_start = match.start(), match.end()
+    assert sub_start - start >= 2
+    if sub_start - start > 2:
+        part_slices_ls.append([start + 2, sub_start])
+    start = sub_start
+    #
+    for match in matches:
+        sub_text = text[sub_start:match.start()]
+        ret = _find_table(text=sub_text)
+        if ret is not None:
+            if start != sub_start:
+                part_slices_ls.append([start, sub_start])
+            table_idx_ls.append(len(part_slices_ls))
+            table_ls.append(ret)
+            part_slices_ls.append([sub_start, match.start()])
+            start = match.start()
+        sub_start = match.end()
+    #
+    assert sub_start - start >= 2
+    if sub_start - start > 2:
+        part_slices_ls.append([start, sub_start - 2])
+    # 移除前面哨兵
+    part_slices_ls = [[i - 2, j - 2] for i, j in part_slices_ls]
+
+    if b_compact_format:
+        return table_ls
+    else:
+        return table_ls, part_slices_ls, table_idx_ls
+
+
+def _find_table(text):
+    # 正则表达式匹配Markdown表格
+    table_pattern = re.compile(r'\|([^\n]+)\|', re.DOTALL)
+    table_matches = table_pattern.findall(text)
+    if len(table_matches) < 2:
+        # 因为一个合法的 markdown 表格需要含有表头的分隔线，所以行数至少应该为 2
+        return None
+
+    # 去除表头的分隔线
+    table_matches.pop(1)
+    #
+    tables = []  # 每个元素为一行
+    for match in table_matches:
+        # 分割每一行
+        tables.append([i.strip() for i in match.split('|', -1)])
+
+    return {"matrix": tables, "orientation": None}
+
+
+if __name__ == '__main__':
+    # # 示例Markdown表格文本
+    # file_path = ""
+    # with open(file_path, 'r') as f:
+    #     markdown_text = f.read()
+
+    markdown_text = """
+| Name | Age | Occupation |
+|------|-----|------------|
+| Alice | 28  | Engineer   |
+| Bob   | 23  | Teacher    |
+| Name | Age | Occupation |
+| Carol | 32  | Hacker   |
+| David | 18  | Student   |
+
+2333
+
+|  | a | b |  | a | b |  | a | b |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- |
+|  | 0 | 2 |  | 4 | 6 |  | 7 | 9 |
+|  | 1 | 3 |  | 5 | 7 |  | 8 | : |
+|  | 2 | 4 |  | 6 | 8 |  | 9 | ; |
+|  | 3 | 5 |  |  |  |  |  |  |
+"""
+
+    # 调用函数并打印结果
+    tables = find_tables(text=markdown_text)
+    print(tables[0])
+    print(tables[1])
+
+    #
+    table_ls_, part_slices_ls_, table_idx_ls_ = find_tables(text=markdown_text, b_compact_format=False)
+    print(table_idx_ls_)
+
+    for part_slices in  part_slices_ls_:
+        print(part_slices)
+        print(markdown_text[part_slices[0]:part_slices[1]])
+

kevin_toolbox/data_flow/file/markdown/{generate_table.py → table/generate_table.py}

@@ -1,4 +1,5 @@
-from kevin_toolbox.math.utils import split_integer_most_evenly
+from kevin_toolbox.data_flow.file.markdown.table import convert_format, Table_Format, padding_misaligned_values
+from kevin_toolbox.data_flow.file.markdown.table.convert import complete_to_matrix
 
 
 def generate_table(content_s, orientation="vertical", chunk_nums=None, chunk_size=None, b_allow_misaligned_values=False,
@@ -36,9 +37,8 @@ def generate_table(content_s, orientation="vertical", chunk_nums=None, chunk_siz
     assert orientation in ["vertical", "horizontal", "h", "v"]
     assert isinstance(content_s, (dict,))
 
-    # 将简易模式转换为完整模式
-    if len(content_s.values()) > 0 and not isinstance(list(content_s.values())[0], (dict,)):
-        content_s = {i: {"title": k, "values": v} for i, (k, v) in enumerate(content_s.items())}
+    # 首先转换为完整模式
+    content_s = convert_format(content_s=content_s, output_format=Table_Format.COMPLETE_DICT)
     # 对齐 values
     len_ls = [len(v["values"]) for v in content_s.values()]
     max_length = max(len_ls)
@@ -46,8 +46,7 @@ def generate_table(content_s, orientation="vertical", chunk_nums=None, chunk_siz
         assert b_allow_misaligned_values, \
             f'The lengths of the values under each title are not aligned. ' \
             f'The maximum length is {max_length}, but each length is {len_ls}'
-        for v in content_s.values():
-            v["values"].extend([""] * (max_length - len(v["values"])))
+        content_s = padding_misaligned_values(content_s=content_s, padding_value="")
     # 对值进行排序
     if callable(f_gen_order_of_values):
         # 检查是否有重复的 title
@@ -58,57 +57,17 @@ def generate_table(content_s, orientation="vertical", chunk_nums=None, chunk_siz
         idx_ls.sort(key=lambda x: f_gen_order_of_values({v["title"]: v["values"][x] for v in content_s.values()}))
         for v in content_s.values():
             v["values"] = [v["values"][i] for i in idx_ls]
-    # 补充缺省的 title
-    for i in range(max(content_s.keys()) + 1):
-        if i not in content_s:
-            content_s[i] = {"title": "", "values": [""] * max_length}
-    # 按照 chunk_nums 或者 chunk_size 对表格进行分割
-    if chunk_nums is not None or chunk_size is not None:
-        if chunk_nums is not None:
-            split_len_ls = split_integer_most_evenly(x=max_length, group_nums=chunk_nums)
-        else:
-            split_len_ls = [chunk_size] * (max_length // chunk_size)
-            if max_length % chunk_size != 0:
-                split_len_ls += [max_length % chunk_size]
-        max_length = max(split_len_ls)
-        temp = dict()
-        beg = 0
-        for i, new_length in enumerate(split_len_ls):
-            end = beg + new_length
-            temp.update({k + i * len(content_s): {"title": v["title"],
-                                                  "values": v["values"][beg:end] + [""] * (max_length - new_length)} for
-                         k, v in content_s.items()})
-            beg = end
-        content_s = temp
-    # 构建表格
-    return _show_table(content_s=content_s, orientation=orientation)
 
-
-def _show_table(content_s, orientation="vertical"):
-    """
-        生成表格
-
-        参数：
-            content_s:              <dict> 内容
-                                        content_s = {<index>: {"title": <title>,"values":<list of value>}, ...}
-                                        此时将取第 <index> 个 "title" 的值来作为第 <index> 个标题的值。values 同理。
-            orientation:            <str> 表格的方向
-                                        支持以下值：
-                                            "vertical" / "v":       纵向排列，亦即标题在第一行
-                                            "horizontal" / "h":     横向排列，亦即标题在第一列
-    """
+    # 转换为 matrix 格式
+    content_s = complete_to_matrix(content_s=content_s, orientation=orientation, chunk_size=chunk_size,
+                                   chunk_nums=chunk_nums)
+    # 构建表格
     table = ""
-    if orientation in ["vertical", "v"]:
-        table += "| " + " | ".join([f'{content_s[i]["title"]}' for i in range(len(content_s))]) + " |\n"
-        table += "| " + " | ".join(["---"] * len(content_s)) + " |\n"
-        for row in zip(*[content_s[i]["values"] for i in range(len(content_s))]):
-            table += "| " + " | ".join([f'{i}' for i in row]) + " |\n"
-    else:
-        for i in range(len(content_s)):
-            row = [f'{content_s[i]["title"]}'] + [f'{i}' for i in content_s[i]["values"]]
-            table += "| " + " | ".join(row) + " |\n"
-            if i == 0:
-                table += "| " + " | ".join(["---"] * len(row)) + " |\n"
+    for idx, row in enumerate(content_s["matrix"]):
+        row = [f'{i}' for i in row]
+        table += "| " + " | ".join(row) + " |\n"
+        if idx == 0:
+            table += "| " + " | ".join(["---"] * len(row)) + " |\n"
     return table
 
 

kevin_toolbox/data_flow/file/markdown/table/get_format.py

@@ -0,0 +1,15 @@
+from kevin_toolbox.data_flow.file.markdown.table import Table_Format
+
+
+def get_format(content_s):
+    res = None
+    if isinstance(content_s, dict):
+        if "orientation" in content_s and isinstance(content_s["orientation"], str):
+            res = Table_Format.MATRIX
+        elif len(content_s) > 0:
+            v = list(content_s.values())[0]  # 是 get_format 而不是 check_format，所以只取第一个值进行判断就够了
+            if isinstance(v, dict):
+                res = Table_Format.COMPLETE_DICT
+            elif isinstance(v, (list, tuple)):
+                res = Table_Format.SIMPLE_DICT
+    return res

kevin_toolbox/data_flow/file/markdown/table/padding_misaligned_values.py

@@ -0,0 +1,22 @@
+from kevin_toolbox.data_flow.file.markdown.table import get_format, Table_Format
+
+
+def padding_misaligned_values(content_s, padding_value=""):
+    """
+        将标题下长度不相等的 values 补齐
+    """
+    format_ = get_format(content_s)
+    if format_ is Table_Format.COMPLETE_DICT:
+        v_ls = [v["values"] for v in content_s.values()]
+    elif format_ is Table_Format.SIMPLE_DICT:
+        v_ls = list(content_s.values())
+    else:
+        raise ValueError(f"unsupported format {format_}")
+
+    len_ls = [len(v) for v in v_ls]
+    max_length = max(len_ls)
+    if min(len_ls) != max_length:
+        for v in v_ls:
+            v.extend([padding_value] * (max_length - len(v)))
+
+    return content_s

kevin_toolbox/data_flow/file/markdown/table/variable.py

@@ -0,0 +1,29 @@
+from enum import Enum
+
+
+class Table_Format(Enum):
+    """
+        表格的几种模式
+            1.simple_dict 简易字典模式：
+                content_s = {<title>: <list of value>, ...}
+                此时键作为标题，值作为标题下的一系列值。
+                由于字典的无序性，此时标题的顺序是不能保证的，若要额外指定顺序，请使用下面的 完整模式。
+            2. complete_dict 完整字典模式:
+                content_s = {<index>: {"title": <title>, "values": <list of value>}, ...}
+                此时将取第 <index> 个 "title" 的值来作为第 <index> 个标题的值。values 同理。
+                该模式允许缺省某些 <index>，此时这些 <index> 对应的行/列将全部置空。
+            3. matrix 矩阵形式：
+                content_s = {"matrix": [[...], [...], ...], "orientation":...(, "chunk_nums":..., "chunk_size":...)}
+                其中，必要的键值对有：
+                    "matrix":           以 list of row 形式保存表格的内容
+                    "orientation":      指定表格的解释方向
+                                            当为 "vertical" 或 "v" 时，表格为竖直方向，此时第一行为标题，
+                                            为 "horizontal" 或 "h" 时，表格为水平方向，此时第一列为标题
+                可选键值对有：
+                    "chunk_nums":       表格是平均分割为多少份进行并列显示。
+                    "chunk_size":       表格是按照最大长度进行分割，然后并列显示。
+                    "b_remove_empty_lines": 是否需要将空行去除掉。
+    """
+    SIMPLE_DICT = "simple_dict"
+    COMPLETE_DICT = "complete_dict"
+    MATRIX = "matrix"

kevin_toolbox/data_flow/file/markdown/utils/__init__.py

@@ -0,0 +1 @@
+from .save_images_in_ndl import save_images_in_ndl

kevin_toolbox/patches/for_matplotlib/common_charts/plot_confusion_matrix.py

@@ -1,11 +1,20 @@
 import os
+import numpy as np
 from sklearn.metrics import confusion_matrix
 import matplotlib.pyplot as plt
 import seaborn as sns
 from kevin_toolbox.patches.for_os.path import replace_illegal_chars
 
 
-def plot_confusion_matrix(data_s, title, gt_name, pd_name, label_to_value_s=None, output_dir=None, **kwargs):
+def plot_confusion_matrix(data_s, title, gt_name, pd_name, label_to_value_s=None, output_dir=None,
+                          replace_zero_division_with=0, **kwargs):
+    """
+        计算并绘制混淆矩阵
+
+        参数：
+            replace_zero_division_with:         <float> 对于在normalize时引发除0错误的矩阵元素，使用何种值进行替代
+                                                    建议使用 np.nan 或者 0
+    """
     paras = {
         "dpi": 200,
         "normalize": None,  # "true", "pred", "all",
@@ -17,10 +26,26 @@ def plot_confusion_matrix(data_s, title, gt_name, pd_name, label_to_value_s=None
     if label_to_value_s is None:
         label_to_value_s = {f'{i}': i for i in value_set}
     else:
-        assert all(i in value_set for i in label_to_value_s.values())
+        # assert all(i in value_set for i in label_to_value_s.values())
+        pass
     # 计算混淆矩阵
     cfm = confusion_matrix(y_true=data_s[gt_name], y_pred=data_s[pd_name], labels=list(label_to_value_s.values()),
                            normalize=paras["normalize"])
+    # replace with nan
+    if paras["normalize"] is not None:
+        if paras["normalize"] == "all":
+            if cfm.sum() == 0:
+                cfm[cfm == 0] = replace_zero_division_with
+        else:
+            check_axis = 1 if paras["normalize"] == "true" else 0
+            temp = np.sum(cfm, axis=check_axis, keepdims=False)
+            for i in range(len(temp)):
+                if temp[i] == 0:
+                    if check_axis == 0:
+                        cfm[:, i] = replace_zero_division_with
+                    else:
+                        cfm[i, :] = replace_zero_division_with
+
     # 绘制混淆矩阵热力图
     plt.clf()
     plt.figure(figsize=(8, 6))
@@ -47,14 +72,13 @@ def plot_confusion_matrix(data_s, title, gt_name, pd_name, label_to_value_s=None
 
 
 if __name__ == '__main__':
-    import numpy as np
-
     # 示例真实标签和预测标签
     y_true = np.array([0, 1, 2, 0, 1, 2, 0, 1, 2, 5])
     y_pred = np.array([0, 2, 1, 0, 2, 1, 0, 1, 1, 5])
 
     plot_confusion_matrix(data_s={'a': y_true, 'b': y_pred},
                           title='test', gt_name='a', pd_name='b',
-                          label_to_value_s={"A": 5, "B": 0, "C": 1, "D": 2},
+                          label_to_value_s={"A": 5, "B": 0, "C": 1, "D": 2, "E": 3},
                           # output_dir=os.path.join(os.path.dirname(__file__), "temp"),
-                          normalize="true")
+                          replace_zero_division_with=-1,
+                          normalize="all")

kevin_toolbox/patches/for_matplotlib/common_charts/plot_lines.py

@@ -1,10 +1,12 @@
 import os
+import copy
 import matplotlib.pyplot as plt
 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):
+    data_s = copy.copy(data_s)
     line_nums = len(data_s) - 1
     paras = {
         "dpi": 200,

kevin_toolbox/patches/for_streamlit/markdown/__init__.py

@@ -0,0 +1,3 @@
+from .show_image import show_image
+from .show_table import show_table
+from .show import show

kevin_toolbox/patches/for_streamlit/markdown/show.py

@@ -0,0 +1,10 @@
+from kevin_toolbox.patches.for_streamlit.markdown import show_table
+
+
+def show(text, doc_dir=None):
+    """
+        st.markdown 的改进版，具有以下优点
+            - 对于带有图片的表格，用分列分行显示
+            - 能够正确显示本地的图片
+    """
+    show_table(text=text, doc_dir=doc_dir)

kevin_toolbox/patches/for_streamlit/markdown/show_image.py

@@ -0,0 +1,40 @@
+import os
+import streamlit as st
+from kevin_toolbox.data_flow.file.markdown.link import find_links
+
+
+def show_image(text, doc_dir=None):
+    """
+        对 st.markdown 中图片显示部分的改进，具有以下优点
+            - 能够正确显示本地的图片，以 st.image 方式或者 base64 方式（待实现 TODO）
+    """
+    link_ls, part_slices_ls, link_idx_ls = find_links(text=text, b_compact_format=False, type_ls=["image"])
+    for i, part_slices in enumerate(part_slices_ls):
+        if i in link_idx_ls:
+            link_s = link_ls.pop(0)
+            st.image(image=os.path.join(doc_dir, link_s["target"]) if doc_dir else link_s["target"],
+                     caption=link_s["name"] or link_s["title"])
+        else:
+            st.markdown(text[slice(*part_slices)])
+
+# from PIL import Image
+# from io import BytesIO
+# import base64
+#
+# def convert_image_to_base64(file_path=None, image=None, output_format="png"):
+#     """
+#         将图片转为 base64 编码的字符串
+#     """
+#     assert output_format in ["png", "jpeg"]
+#     if file_path:
+#         image = Image.open(file_path)
+#     assert image is not None
+#     with BytesIO() as buffer:
+#         image.save(buffer, 'png')  # or 'jpeg'
+#         res = base64.b64encode(buffer.getvalue()).decode('utf-8')
+#     return res
+#
+#
+# if __name__ == "__main__":
+#     image_path = "/home/SENSETIME/xukaiming/Desktop/gitlab_repos/face_liveness_datasets/deploy_for_streamlit/pages/test/test_data/images/7.jpg"
+#     print(convert_image_to_base64(image_path))

kevin_toolbox/patches/for_streamlit/markdown/show_table.py

@@ -0,0 +1,82 @@
+import streamlit as st
+from kevin_toolbox.data_flow.file.markdown.table import find_tables
+from kevin_toolbox.data_flow.file.markdown.link import find_links
+from kevin_toolbox.computer_science.algorithm.for_dict import deep_update
+from kevin_toolbox.patches.for_streamlit.markdown import show_image
+
+DEFAULT_DISPLAY_MODE_S = {
+    "table_with_image": "by_columns",  # 对于带有图片的表格选择哪种方式显示
+    "default": "by_markdown"  # 对于其他表格选择哪种方式显示
+}
+
+
+def _show_table_by_columns(matrix, doc_dir, table_name, **kwargs):
+    tab, _ = st.tabs([table_name, "[click to hide table]"])
+    with tab:
+        for row in matrix:
+            col_ls = st.columns(len(row))
+            for col, i in zip(col_ls, row):
+                with col:
+                    show_image(text=i, doc_dir=doc_dir)
+
+
+METHOD_S = {
+    "by_columns": _show_table_by_columns,
+    "by_markdown": lambda text, **kwargs: st.markdown(text)
+}
+
+
+def show_table(text, doc_dir=None, display_mode_s=None):
+    """
+        对 st.markdown 中表格显示部分的改进，具有以下优点
+            - 支持显示带有本地图片的表格
+            - 支持以下几种方式来显示表格：
+                - 用 st.columns 分列分行显示
+                - 用 st.markdown 显示（不支持本地图片）
+                - 用 st.data_editor 显示（TODO）
+    """
+    global DEFAULT_DISPLAY_MODE_S, METHOD_S
+    display_mode_s = deep_update(stem=DEFAULT_DISPLAY_MODE_S.copy(), patch=display_mode_s if display_mode_s else dict())
+    for v in display_mode_s.values():
+        assert v in ["by_columns", "by_markdown"]  # "by_data_editor"
+
+    table_ls, part_slices_ls, table_idx_ls = find_tables(text=text, b_compact_format=False)
+    for idx, part_slices in enumerate(part_slices_ls):
+        part = text[slice(*part_slices)]
+        if idx in table_idx_ls:
+            table_s = table_ls.pop(0)
+            if len(find_links(text=part, b_compact_format=True, type_ls=["image"])) > 0:
+                # 带有图片的表格
+                method = METHOD_S[display_mode_s["table_with_image"]]
+            else:
+                method = METHOD_S[display_mode_s["default"]]
+            method(text=part, matrix=table_s["matrix"], doc_dir=doc_dir, table_name=f'Table {idx}')
+        else:
+            # 是表格，且内部无图片，则直接显示
+            show_image(text=part, doc_dir=None)
+
+# 另一种显示表格的方式是通过 data_editor 来显示，但是对图片的显示效果不好
+# TODO 可以选择是通过 data_editor 还是 columns，或者原始格式（对本地图片不处理或者使用 base64 代替）来显示表格
+# # 创建一个 DataFrame
+# data = {
+#     'Description': ['This is an image.', "2"],
+#     'Image': [f'data:image/png;base64,{convert_image_to_base64(temp)}', temp]  # 使用 Markdown 格式的图片
+# }
+#
+# column_configuration = {
+#     "Image": st.column_config.ImageColumn("Avatar", help="The user's avatar", width="large")
+# }
+#
+# import pandas as pd
+#
+# df = pd.DataFrame(data)
+#
+# # 创建表格
+# # st.table(df)
+# st.data_editor(
+#     df,
+#     column_config=column_configuration,
+#     use_container_width=True,
+#     hide_index=True,
+#     num_rows="fixed"
+# )

{kevin_toolbox_dev-1.3.9.dist-info → kevin_toolbox_dev-1.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kevin-toolbox-dev
-Version: 1.3.9
+Version: 1.4.1
 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
@@ -51,8 +51,17 @@ pip install kevin-toolbox  --no-dependencies
 
 [版本更新记录](./notes/Release_Record.md)：
 
-- v 1.3.9 （2024-08-13）【bug fix】【temporary version】
-  - computer_science.algorithm.registration
-    - modify Registry.collect_from_paths() for python>=3.12，在更高版本的python的importlib中 find_module() 方法已被废弃和移除，因此需要替换为 find_spec() 方法。
+- v 1.4.1 （2024-09-23）【bug fix】【new feature】 
+  - patches
+    - for_streamlit.markdown
+      - 【bug fix】fix bug in show_table()，将原来的使用 st.expander 去包裹表格，改为使用 st.tabs 去包裹表格，避免在 streamlit<=1.38.0 下（截止2024-09-23最新版本），因为 st.expander 嵌套使用而造成的报错。具体参看：https://docs.streamlit.io/develop/api-reference/layout/st.expander
+      - 【bug fix】fix bug in show_table()，修复在 line 56 和 line 25 中对 show_image() 和 st.markdown 的函数参数写错，导致在显示无图表格时反而报错的问题。
+      - 增加了测试用例。
+
+    - for_matplotlib.common_charts
+      - 【new feature】 add para replace_zero_division_with to plot_confusion_matrix()，新增参数 replace_zero_division_with 用于指定在normalize时引发除0错误的矩阵元素要使用何种值进行替代。
+      - 增加了测试用例。
+
+
 
 

{kevin_toolbox_dev-1.3.9.dist-info → kevin_toolbox_dev-1.4.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-kevin_toolbox/__init__.py,sha256=mqgXT0DiSzNPKGVSNm76FMSgAzUhwSTG1Dl4i66a8xQ,410
+kevin_toolbox/__init__.py,sha256=7isptekqTWuS1t1NRWNgtllHGRDc1eNX2UVtujkt5NM,410
 kevin_toolbox/computer_science/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kevin_toolbox/computer_science/algorithm/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 kevin_toolbox/computer_science/algorithm/cache_manager/__init__.py,sha256=p2hddkZ1HfYF9-m2Hx-o9IotwQHd4QwDCePy2ADpTDA,41
@@ -96,14 +96,23 @@ kevin_toolbox/data_flow/file/kevin_notation/test/test_data/__init__.py,sha256=47
 kevin_toolbox/data_flow/file/kevin_notation/test/test_data/data_0.py,sha256=CKRb86O3JV9lkGrMtyJzEH041o0xABfT32Zo4GQ5Qis,324
 kevin_toolbox/data_flow/file/kevin_notation/test/test_data/data_1.py,sha256=Xs8oFJqwi0uPOJewulij7DY0iMEp6dWBMiiDIwPlm4s,176
 kevin_toolbox/data_flow/file/kevin_notation/test/test_data/data_all.py,sha256=cvwrNzMVqB2YF1Ya3pw4NSOOzQBcGCFVCB2lN-sKmfw,438
-kevin_toolbox/data_flow/file/markdown/__init__.py,sha256=oPUUDFM0i3roBPLJm6jleF_uSq1_2_fD0-zG_7n2lys,250
-kevin_toolbox/data_flow/file/markdown/find_tables.py,sha256=YZrdy0koiG_KMCNeJFtNShzx9f1whg0xnaBhB0F8k4o,1699
-kevin_toolbox/data_flow/file/markdown/generate_link.py,sha256=9okSyCFIDQW5T35a6-epVyoCkCL1vFH5215P5MRXfYk,304
+kevin_toolbox/data_flow/file/markdown/__init__.py,sha256=LJQBXClkuLylO2ufconMfpxckc-lqD4yLuDwNYWXfF8,173
 kevin_toolbox/data_flow/file/markdown/generate_list.py,sha256=Gv5BcqWE4M4w8ADN8NX5LyD9DxILXTQtJvcazi_NuyE,1006
-kevin_toolbox/data_flow/file/markdown/generate_table.py,sha256=u-FLyjQi7R7xkKmSZSyXBCWVMuICYfShSgBlz-vptkI,7991
-kevin_toolbox/data_flow/file/markdown/parse_table.py,sha256=aKR8SNpA3Tr24GZQRtr2mx7TQYYKhNLArV9su5H5kWU,5957
-kevin_toolbox/data_flow/file/markdown/save_images_in_ndl.py,sha256=F_c6FP4QgWjlCF_ftSDpa6KoyfUrlE3cH216_w_0q3E,3897
-kevin_toolbox/data_flow/file/markdown/variable.py,sha256=fQp_wxhXJv_HosuaiiEPkDTodT4jzcxN19HXGAzeckc,857
+kevin_toolbox/data_flow/file/markdown/link/__init__.py,sha256=JepoQDbZX4AMwImRDAQ0YuaSfCNJbJDG15_bBQk5JRU,76
+kevin_toolbox/data_flow/file/markdown/link/find_links.py,sha256=bj3vCVnduEyaitp8HiwI5Doa39WG0ESEWBNI96S1Lu0,3024
+kevin_toolbox/data_flow/file/markdown/link/generate_link.py,sha256=obuHoh8VEPeddHetsJWuNtqrtaHesYPSd51FLPjAH4o,394
+kevin_toolbox/data_flow/file/markdown/table/__init__.py,sha256=kLWziykXpOKwebDZan3vrXjICVHJMn8Jt6FSWm9Oz9E,258
+kevin_toolbox/data_flow/file/markdown/table/convert_format.py,sha256=JT7AZsQi3h5XZsz6PAvAQKbWIkpLsjIyAFv6Iiwt5H8,2652
+kevin_toolbox/data_flow/file/markdown/table/find_tables.py,sha256=LC--ECb_A4XVsDGfYE8tj-hO2JDWbptpyHri7m_DBpY,3614
+kevin_toolbox/data_flow/file/markdown/table/generate_table.py,sha256=jFd1OT5Er65Mg5x6KTEQ4FD1HnlcurpZNYNaAg_E-NQ,5879
+kevin_toolbox/data_flow/file/markdown/table/get_format.py,sha256=jEVxFwzP2n-YMrm9q5Yc6PPB7bEuSydWvw70werAhzo,632
+kevin_toolbox/data_flow/file/markdown/table/padding_misaligned_values.py,sha256=kbme0KXCPwjIoJVd9wIs7l0q_kicu3PzZjtcwWecH9E,712
+kevin_toolbox/data_flow/file/markdown/table/variable.py,sha256=JXtht8HvzcZEc-To7XYtwwUtc-4d0bRYYUBI7tCBUEI,1805
+kevin_toolbox/data_flow/file/markdown/table/convert/__init__.py,sha256=9jpD4Siq3bok35PNaPf9C9oicGRHPBIOSYjag72-gQg,102
+kevin_toolbox/data_flow/file/markdown/table/convert/complete_to_matrix.py,sha256=mAskwCh1EevPCxmXYV2IkHH8XUGa9eIHZgumEdDYZb8,5197
+kevin_toolbox/data_flow/file/markdown/table/convert/matrix_to_complete.py,sha256=igZE8f8918llx8tOGyqL0W6gK1rAFrEYmgSrUn0M2w0,4540
+kevin_toolbox/data_flow/file/markdown/utils/__init__.py,sha256=G86gkuOiDKsv2NMe4uSU6sy9vdAePeayEQJAujC0rN0,51
+kevin_toolbox/data_flow/file/markdown/utils/save_images_in_ndl.py,sha256=F_c6FP4QgWjlCF_ftSDpa6KoyfUrlE3cH216_w_0q3E,3897
 kevin_toolbox/developing/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 kevin_toolbox/developing/general_matrix_multiplication.py,sha256=Ie9c8mYBYR-Bg7CjU4L1dsOxXsxnx1jz-rA7_ez7vjg,2089
 kevin_toolbox/developing/test.py,sha256=6Y23SY3FJVrvZmiiXKNPKv84lhVRW-XyjNeecj9lLYA,241
@@ -272,9 +281,9 @@ kevin_toolbox/patches/for_matplotlib/color/generate_color_list.py,sha256=TZm-TkO
 kevin_toolbox/patches/for_matplotlib/color/get_format.py,sha256=l_vX8DUsWHNzLwveuF60TLcbQ_P7PvVt1yH_7FjElDs,312
 kevin_toolbox/patches/for_matplotlib/common_charts/__init__.py,sha256=etey2r0LO4PTLnH3VzcRKFe7IHP9I5TMW3DEz3sQx2c,270
 kevin_toolbox/patches/for_matplotlib/common_charts/plot_bars.py,sha256=crS1h79Dz6gGOnqhjuuN2o5pl8CekhCenx9lRz5KPiI,1887
-kevin_toolbox/patches/for_matplotlib/common_charts/plot_confusion_matrix.py,sha256=dxkgiXeoIdtXzcg_HoUnRGqhJk91iNoB5VbLuoG7o_M,2191
+kevin_toolbox/patches/for_matplotlib/common_charts/plot_confusion_matrix.py,sha256=KtmUAlKs3_ALFRKAEi0OAXj6SyG5L7LMmoSgOxKvvVs,3213
 kevin_toolbox/patches/for_matplotlib/common_charts/plot_distribution.py,sha256=stuyaULWM_vVW3r9WrpzGqA8rohQrdNKT3Agsbobqck,2396
-kevin_toolbox/patches/for_matplotlib/common_charts/plot_lines.py,sha256=rb95pupvaiEiGi3o0CP2v-qcOkl1nYF_kgxCTSLGPjI,1991
+kevin_toolbox/patches/for_matplotlib/common_charts/plot_lines.py,sha256=j2GBT_E9tvQhLN2ynCknuBl1MjD6q2TZeNYGvm2IVRA,2034
 kevin_toolbox/patches/for_matplotlib/common_charts/plot_scatters.py,sha256=whO36bmixjwtsjCS6Ah6zEGJAlJyGcD-wmV3dA6u7mk,1658
 kevin_toolbox/patches/for_matplotlib/common_charts/plot_scatters_matrix.py,sha256=bf2EfGlPW9dtDfRse1gk8RVxvC8CJ0NeMdrpSw43wFg,1989
 kevin_toolbox/patches/for_numpy/__init__.py,sha256=SNjZGxTRBn-uzkyZi6Jcz-9juhhZKT8TI70qH-fhGGc,21
@@ -311,6 +320,11 @@ kevin_toolbox/patches/for_os/walk.py,sha256=LrtEeRUDwzZgu_zGZ-kPsFJd4D-8R8ECHW6W
 kevin_toolbox/patches/for_os/path/__init__.py,sha256=M4XaYawTDj-SjwZ_bWS5D38lqzPujxvAtVEvzRLDhtU,108
 kevin_toolbox/patches/for_os/path/find_illegal_chars.py,sha256=QmqzeaeBY50of28qtvfEmnDW9xeVIfCXi6QVzLzngks,1416
 kevin_toolbox/patches/for_os/path/replace_illegal_chars.py,sha256=OhxndHEJ8xK-ip-sWYQehTNSho8eNFeKj2iwPHR02os,1672
+kevin_toolbox/patches/for_streamlit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kevin_toolbox/patches/for_streamlit/markdown/__init__.py,sha256=ZWNRNA7yn3LD_YMjBuUHrXcxDcG4iswIZtCJVCnRVB0,93
+kevin_toolbox/patches/for_streamlit/markdown/show.py,sha256=uSkArSUv8N05TFWsIpXa8f15uhN1Lpm0ZHZst_IytgY,327
+kevin_toolbox/patches/for_streamlit/markdown/show_image.py,sha256=8njiSDiPWWRNwevvpgipxZS3My7bGHp9j0dxLiut_x8,1546
+kevin_toolbox/patches/for_streamlit/markdown/show_table.py,sha256=mZu37G9lqtpSEP62YLv88rDw-OSe8BCFkmSa2UQt6fY,3251
 kevin_toolbox/patches/for_test/__init__.py,sha256=sFr2VZD1zk8Vtjq2_F8uE4xNovJF6yDY8j1YND5XAw0,49
 kevin_toolbox/patches/for_test/check_consistency.py,sha256=cerf4NywkvWYMvuJUjimfRRVU7D9vL30jTAX0NxxRoM,9422
 kevin_toolbox/patches/for_torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -328,7 +342,7 @@ kevin_toolbox/patches/for_torch/math/get_y_at_x.py,sha256=bfoVcasZ_tMdhR_1Me0Jli
 kevin_toolbox/patches/for_torch/math/my_around.py,sha256=ptpU3ids50gwf663EpHbw7raj9tNrDGBFZ5t_uMNH14,1378
 kevin_toolbox/patches/for_torch/nn/__init__.py,sha256=aJs3RMqRzQmd8KKDmQW9FxwCqS5yfPqEdg-m0PwlQro,39
 kevin_toolbox/patches/for_torch/nn/lambda_layer.py,sha256=KUuLiX_Dr4bvRmpAaCW5QTDWDcnMPRnw0jg4NNXTFhM,223
-kevin_toolbox_dev-1.3.9.dist-info/METADATA,sha256=_JXWhGRD_pNuYvb7F6aGl_hpSL9JtqWJZNX4daYlKok,1576
-kevin_toolbox_dev-1.3.9.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-kevin_toolbox_dev-1.3.9.dist-info/top_level.txt,sha256=S5TeRGF-PwlhsaUEPTI-f2vWrpLmh3axpyI6v-Fi75o,14
-kevin_toolbox_dev-1.3.9.dist-info/RECORD,,
+kevin_toolbox_dev-1.4.1.dist-info/METADATA,sha256=b3yGqO3ykWWJRAx1ChCx9N_v_ezAfbIwchtFwrgtt3U,2234
+kevin_toolbox_dev-1.4.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+kevin_toolbox_dev-1.4.1.dist-info/top_level.txt,sha256=S5TeRGF-PwlhsaUEPTI-f2vWrpLmh3axpyI6v-Fi75o,14
+kevin_toolbox_dev-1.4.1.dist-info/RECORD,,

kevin_toolbox/data_flow/file/markdown/find_tables.py

@@ -1,65 +0,0 @@
-import re
-
-
-def find_tables(text):
-    """
-        查找文本中的表格
-            将返回一个列表，列表每个元素系一个二维的数组，表示一个原始的表格
-    """
-    table_ls = []
-    for sub_text in text.split('\n\n', -1):
-        ret = _find_table(text=sub_text)
-        if ret is not None:
-            table_ls.append(ret)
-
-    return table_ls
-
-
-def _find_table(text):
-    # 正则表达式匹配Markdown表格
-    table_pattern = re.compile(r'\|([^\n]+)\|', re.DOTALL)
-    table_matches = table_pattern.findall(text)
-    if len(table_matches) < 2:
-        # 因为一个合法的 markdown 表格需要含有表头的分隔线，所以行数至少应该为 2
-        return None
-
-    # 去除表头的分隔线
-    table_matches.pop(1)
-    #
-    tables = []  # 每个元素为一行
-    for match in table_matches:
-        # 分割每一行
-        tables.append([i.strip() for i in match.split('|', -1)])
-
-    return tables
-
-
-if __name__ == '__main__':
-    # # 示例Markdown表格文本
-    # file_path = ""
-    # with open(file_path, 'r') as f:
-    #     markdown_text = f.read()
-
-    markdown_text = """
-| Name | Age | Occupation |
-|------|-----|------------|
-| Alice | 28  | Engineer   |
-| Bob   | 23  | Teacher    |
-| Name | Age | Occupation |
-| Carol | 32  | Hacker   |
-| David | 18  | Student   |
-
-2333
-
-|  | a | b |  | a | b |  | a | b |
-| --- | --- | --- | --- | --- | --- | --- | --- | --- |
-|  | 0 | 2 |  | 4 | 6 |  | 7 | 9 |
-|  | 1 | 3 |  | 5 | 7 |  | 8 | : |
-|  | 2 | 4 |  | 6 | 8 |  | 9 | ; |
-|  | 3 | 5 |  |  |  |  |  |  |
-"""
-
-    # 调用函数并打印结果
-    tables = find_tables(text=markdown_text)
-    print(tables[0])
-    print(tables[1])

kevin_toolbox/data_flow/file/markdown/generate_link.py

@@ -1,8 +0,0 @@
-def generate_link(name, target, type_="url"):
-    assert type_ in ["url", "image"]
-    return f'{"!" if type_ == "image" else ""}[{name}]({target})'
-
-
-if __name__ == '__main__':
-    print(generate_link(name=444, target="233", type_="url"))
-    print(generate_link(name=444, target="233", type_="image"))

kevin_toolbox/data_flow/file/markdown/variable.py

@@ -1,17 +0,0 @@
-from enum import Enum
-
-
-class Table_Format(Enum):
-    """
-        表格的几种模式
-            1.simple_dict 简易字典模式：
-                content_s = {<title>: <list of value>, ...}
-                此时键作为标题，值作为标题下的一系列值。
-                由于字典的无序性，此时标题的顺序是不能保证的，若要额外指定顺序，请使用下面的 完整模式。
-            2. complete_dict 完整字典模式:
-                content_s = {<index>: {"title": <title>,"values":<list of value>}, ...}
-                此时将取第 <index> 个 "title" 的值来作为第 <index> 个标题的值。values 同理。
-                该模式允许缺省某些 <index>，此时这些 <index> 对应的行/列将全部置空。
-    """
-    SIMPLE_DICT = "simple_dict"
-    COMPLETE_DICT = "complete_dict"