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

{kevin-toolbox-dev-1.3.9 → kevin-toolbox-dev-1.4.1}/PKG-INFO

@@ -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
@@ -46,8 +46,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.4.1/README.md

@@ -0,0 +1,41 @@
+# 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.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 → kevin-toolbox-dev-1.4.1}/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-dev-1.4.1/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.1/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.1/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.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-dev-1.4.1/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.1/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.1/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.1/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.1/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.1/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]])
+