kevin-toolbox-dev 1.3.9__tar.gz → 1.4.0__tar.gz

kevin-toolbox-dev-1.4.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.4.0
+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.0 （2024-09-11）【bug fix】【new feature】【incompatible change】
+  - patches
+    - for_matplotlib.common_charts
+      - 【bug fix】fix bug in plot_confusion_matrix() for paras label_to_value_s，删除了对参数 label_to_value_s 的不合理的检验，并且支持更加自由的 label_to_value_s 设置，比如允许 label_to_value_s 中缺少 data_s 中已有的 label_idx，或者含有部分 data_s 中未见的 label_idx。
+      - 【bug fix】fix bug in plot_lines()，对接受的输入 data_s 进行 copy，避免后续操作引起输入意外改变。
+      - 增加测试用例。
+    - for_streamlit.markdown
+      - 【new feature】add show_image()，对 st.markdown 中图片显示部分的改进，能够正确显示本地的图片。
+      - 【new feature】add show_table()，对 st.markdown 中表格显示部分的改进，支持以下多种方式来显示表格。
+      - 【new feature】add show()，st.markdown 的改进版。
+      - 增加测试用例。
+  - data_flow.file
+    - markdown【incompatible change】【new feature】
+      - 【refactor and modify】
+        - generate_table() ==> table.generate_table()
+        - generate_link() ==> link.generate_link()
+        - save_images_in_ndl() ==> utils.save_images_in_ndl()
+        - parse_table() ，可以使用 table.convert_format() 来代替实现表格格式的转换
+      - table
+        - 【new feature】新增 Table_Format、get_format()、convert_format() 用于表格格式的转换，目前支持以下几种格式：
+          - simple_dict 简易字典模式：`{<title>: <list of value>, ...}`
+          - complete_dict 完整字典模式：`{<index>: {"title": <title>, "values": <list of value>}, ...}`
+          - matrix 矩阵形式：`{"matrix": [[...], [...], ...], "orientation":...(, "chunk_nums":..., "chunk_size":...)}`
+        - 【new feature】add find_tables()，查找文本中的表格
+          - 当 b_compact_format 设为 True，此时返回 table_ls，其中每个元素是一个 MATRIX 格式的表格
+          - 当 b_compact_format 设置为 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 依次对应。
+        - 【new feature】add padding_misaligned_values()， 将标题下长度不相等的 values 补齐
+        - convert
+          - 格式转换相关的函数，包括 complete_to_matrix() 和 matrix_to_complete()
+      - link
+        - 【new feature】add find_links()，查找文本中的链接。与find_tables()类似，也支持 b_compact_format 参数。
+      - 增加测试用例。
+
+
+

kevin-toolbox-dev-1.4.0/README.md

@@ -0,0 +1,62 @@
+# 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.0 （2024-09-11）【bug fix】【new feature】【incompatible change】
+  - patches
+    - for_matplotlib.common_charts
+      - 【bug fix】fix bug in plot_confusion_matrix() for paras label_to_value_s，删除了对参数 label_to_value_s 的不合理的检验，并且支持更加自由的 label_to_value_s 设置，比如允许 label_to_value_s 中缺少 data_s 中已有的 label_idx，或者含有部分 data_s 中未见的 label_idx。
+      - 【bug fix】fix bug in plot_lines()，对接受的输入 data_s 进行 copy，避免后续操作引起输入意外改变。
+      - 增加测试用例。
+    - for_streamlit.markdown
+      - 【new feature】add show_image()，对 st.markdown 中图片显示部分的改进，能够正确显示本地的图片。
+      - 【new feature】add show_table()，对 st.markdown 中表格显示部分的改进，支持以下多种方式来显示表格。
+      - 【new feature】add show()，st.markdown 的改进版。
+      - 增加测试用例。
+  - data_flow.file
+    - markdown【incompatible change】【new feature】
+      - 【refactor and modify】
+        - generate_table() ==> table.generate_table()
+        - generate_link() ==> link.generate_link()
+        - save_images_in_ndl() ==> utils.save_images_in_ndl()
+        - parse_table() ，可以使用 table.convert_format() 来代替实现表格格式的转换
+      - table
+        - 【new feature】新增 Table_Format、get_format()、convert_format() 用于表格格式的转换，目前支持以下几种格式：
+          - simple_dict 简易字典模式：`{<title>: <list of value>, ...}`
+          - complete_dict 完整字典模式：`{<index>: {"title": <title>, "values": <list of value>}, ...}`
+          - matrix 矩阵形式：`{"matrix": [[...], [...], ...], "orientation":...(, "chunk_nums":..., "chunk_size":...)}`
+        - 【new feature】add find_tables()，查找文本中的表格
+          - 当 b_compact_format 设为 True，此时返回 table_ls，其中每个元素是一个 MATRIX 格式的表格
+          - 当 b_compact_format 设置为 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 依次对应。
+        - 【new feature】add padding_misaligned_values()， 将标题下长度不相等的 values 补齐
+        - convert
+          - 格式转换相关的函数，包括 complete_to_matrix() 和 matrix_to_complete()
+      - link
+        - 【new feature】add find_links()，查找文本中的链接。与find_tables()类似，也支持 b_compact_format 参数。
+      - 增加测试用例。
+

{kevin-toolbox-dev-1.3.9 → kevin-toolbox-dev-1.4.0}/kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.3.9"
+__version__ = "1.4.0"
 
 
 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 1741603427 --verbose 0'
 )

kevin-toolbox-dev-1.4.0/kevin_toolbox/data_flow/file/markdown/__init__.py

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

kevin-toolbox-dev-1.4.0/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-dev-1.4.0/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-dev-1.4.0/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-dev-1.4.0/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-dev-1.4.0/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-dev-1.4.0/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-dev-1.3.9/kevin_toolbox/data_flow/file/markdown/parse_table.py → kevin-toolbox-dev-1.4.0/kevin_toolbox/data_flow/file/markdown/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-dev-1.4.0/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-dev-1.4.0/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]])
+