magic-pdf 0.10.0__py3-none-any.whl → 0.10.2__py3-none-any.whl

magic_pdf/pre_proc/ocr_dict_merge.py

@@ -1,8 +1,5 @@
-from magic_pdf.config.drop_tag import DropTag
 from magic_pdf.config.ocr_content_type import BlockType, ContentType
-from magic_pdf.libs.boxbase import (__is_overlaps_y_exceeds_threshold,
-                                    _is_in_or_part_overlap_with_area_ratio,
-                                    calculate_overlap_area_in_bbox1_area_ratio)
+from magic_pdf.libs.boxbase import __is_overlaps_y_exceeds_threshold, calculate_overlap_area_in_bbox1_area_ratio
 
 
 # 将每一个line中的span从左到右排序
@@ -63,86 +60,6 @@ def merge_spans_to_line(spans, threshold=0.6):
         return lines
 
 
-def merge_spans_to_line_by_layout(spans, layout_bboxes):
-    lines = []
-    new_spans = []
-    dropped_spans = []
-    for item in layout_bboxes:
-        layout_bbox = item['layout_bbox']
-        # 遍历spans,将每个span放入对应的layout中
-        layout_sapns = []
-        for span in spans:
-            if calculate_overlap_area_in_bbox1_area_ratio(
-                    span['bbox'], layout_bbox) > 0.6:
-                layout_sapns.append(span)
-        # 如果layout_sapns不为空，则放入new_spans中
-        if len(layout_sapns) > 0:
-            new_spans.append(layout_sapns)
-            # 从spans删除已经放入layout_sapns中的span
-            for layout_sapn in layout_sapns:
-                spans.remove(layout_sapn)
-
-    if len(new_spans) > 0:
-        for layout_sapns in new_spans:
-            layout_lines = merge_spans_to_line(layout_sapns)
-            lines.extend(layout_lines)
-
-    # 对line中的span进行排序
-    lines = line_sort_spans_by_left_to_right(lines)
-
-    for span in spans:
-        span['tag'] = DropTag.NOT_IN_LAYOUT
-        dropped_spans.append(span)
-
-    return lines, dropped_spans
-
-
-def merge_lines_to_block(lines):
-    # 目前不做block拼接,先做个结构,每个block中只有一个line,block的bbox就是line的bbox
-    blocks = []
-    for line in lines:
-        blocks.append({
-            'bbox': line['bbox'],
-            'lines': [line],
-        })
-    return blocks
-
-
-def sort_blocks_by_layout(all_bboxes, layout_bboxes):
-    new_blocks = []
-    sort_blocks = []
-    for item in layout_bboxes:
-        layout_bbox = item['layout_bbox']
-
-        # 遍历blocks,将每个blocks放入对应的layout中
-        layout_blocks = []
-        for block in all_bboxes:
-            # 如果是footnote则跳过
-            if block[7] == BlockType.Footnote:
-                continue
-            block_bbox = block[:4]
-            if calculate_overlap_area_in_bbox1_area_ratio(
-                    block_bbox, layout_bbox) > 0.8:
-                layout_blocks.append(block)
-
-        # 如果layout_blocks不为空，则放入new_blocks中
-        if len(layout_blocks) > 0:
-            new_blocks.append(layout_blocks)
-            # 从all_bboxes删除已经放入layout_blocks中的block
-            for layout_block in layout_blocks:
-                all_bboxes.remove(layout_block)
-
-    # 如果new_blocks不为空，则对new_blocks中每个block进行排序
-    if len(new_blocks) > 0:
-        for bboxes_in_layout_block in new_blocks:
-            bboxes_in_layout_block.sort(
-                key=lambda x: x[1])  # 一个layout内部的box，按照y0自上而下排序
-            sort_blocks.extend(bboxes_in_layout_block)
-
-    # sort_blocks中已经包含了当前页面所有最终留下的block，且已经排好了顺序
-    return sort_blocks
-
-
 def fill_spans_in_blocks(blocks, spans, radio):
     """将allspans中的span按位置关系，放入blocks中."""
     block_with_spans = []
@@ -164,14 +81,6 @@ def fill_spans_in_blocks(blocks, spans, radio):
             if calculate_overlap_area_in_bbox1_area_ratio(
                     span_bbox, block_bbox) > radio:
                 block_spans.append(span)
-        '''行内公式调整, 高度调整至与同行文字高度一致(优先左侧, 其次右侧)'''
-        # displayed_list = []
-        # text_inline_lines = []
-        # modify_y_axis(block_spans, displayed_list, text_inline_lines)
-        '''模型识别错误的行间公式, type类型转换成行内公式'''
-        # block_spans = modify_inline_equation(block_spans, displayed_list, text_inline_lines)
-        '''bbox去除粘连'''  # 去粘连会影响span的bbox，导致后续fill的时候出错
-        # block_spans = remove_overlap_between_bbox_for_span(block_spans)
 
         block_dict['spans'] = block_spans
         block_with_spans.append(block_dict)
@@ -184,32 +93,7 @@ def fill_spans_in_blocks(blocks, spans, radio):
     return block_with_spans, spans
 
 
-def fix_block_spans(block_with_spans, img_blocks, table_blocks):
-    """1、img_block和table_block因为包含caption和footnote的关系，存在block的嵌套关系
-    需要将caption和footnote的text_span放入相应img_block和table_block内的
-    caption_block和footnote_block中 2、同时需要删除block中的spans字段."""
-    fix_blocks = []
-    for block in block_with_spans:
-        block_type = block['type']
-
-        if block_type == BlockType.Image:
-            block = fix_image_block(block, img_blocks)
-        elif block_type == BlockType.Table:
-            block = fix_table_block(block, table_blocks)
-        elif block_type in [BlockType.Text, BlockType.Title]:
-            block = fix_text_block(block)
-        elif block_type == BlockType.InterlineEquation:
-            block = fix_interline_block(block)
-        else:
-            continue
-        fix_blocks.append(block)
-    return fix_blocks
-
-
 def fix_block_spans_v2(block_with_spans):
-    """1、img_block和table_block因为包含caption和footnote的关系，存在block的嵌套关系
-    需要将caption和footnote的text_span放入相应img_block和table_block内的
-    caption_block和footnote_block中 2、同时需要删除block中的spans字段."""
     fix_blocks = []
     for block in block_with_spans:
         block_type = block['type']
@@ -235,113 +119,6 @@ def fix_discarded_block(discarded_block_with_spans):
     return fix_discarded_blocks
 
 
-def merge_spans_to_block(spans: list, block_bbox: list, block_type: str):
-    block_spans = []
-    # 如果有img_caption，则将img_block中的text_spans放入img_caption_block中
-    for span in spans:
-        if calculate_overlap_area_in_bbox1_area_ratio(span['bbox'],
-                                                      block_bbox) > 0.6:
-            block_spans.append(span)
-    block_lines = merge_spans_to_line(block_spans)
-    # 对line中的span进行排序
-    sort_block_lines = line_sort_spans_by_left_to_right(block_lines)
-    block = {'bbox': block_bbox, 'type': block_type, 'lines': sort_block_lines}
-    return block, block_spans
-
-
-def make_body_block(span: dict, block_bbox: list, block_type: str):
-    # 创建body_block
-    body_line = {
-        'bbox': block_bbox,
-        'spans': [span],
-    }
-    body_block = {'bbox': block_bbox, 'type': block_type, 'lines': [body_line]}
-    return body_block
-
-
-def fix_image_block(block, img_blocks):
-    block['blocks'] = []
-    # 遍历img_blocks,找到与当前block匹配的img_block
-    for img_block in img_blocks:
-        if _is_in_or_part_overlap_with_area_ratio(block['bbox'],
-                                                  img_block['bbox'], 0.95):
-
-            # 创建img_body_block
-            for span in block['spans']:
-                if span['type'] == ContentType.Image and img_block[
-                        'img_body_bbox'] == span['bbox']:
-                    # 创建img_body_block
-                    img_body_block = make_body_block(
-                        span, img_block['img_body_bbox'], BlockType.ImageBody)
-                    block['blocks'].append(img_body_block)
-
-                    # 从spans中移除img_body_block中已经放入的span
-                    block['spans'].remove(span)
-                    break
-
-            # 根据list长度，判断img_block中是否有img_caption
-            if img_block['img_caption_bbox'] is not None:
-                img_caption_block, img_caption_spans = merge_spans_to_block(
-                    block['spans'], img_block['img_caption_bbox'],
-                    BlockType.ImageCaption)
-                block['blocks'].append(img_caption_block)
-
-            if img_block['img_footnote_bbox'] is not None:
-                img_footnote_block, img_footnote_spans = merge_spans_to_block(
-                    block['spans'], img_block['img_footnote_bbox'],
-                    BlockType.ImageFootnote)
-                block['blocks'].append(img_footnote_block)
-            break
-    del block['spans']
-    return block
-
-
-def fix_table_block(block, table_blocks):
-    block['blocks'] = []
-    # 遍历table_blocks,找到与当前block匹配的table_block
-    for table_block in table_blocks:
-        if _is_in_or_part_overlap_with_area_ratio(block['bbox'],
-                                                  table_block['bbox'], 0.95):
-
-            # 创建table_body_block
-            for span in block['spans']:
-                if span['type'] == ContentType.Table and table_block[
-                        'table_body_bbox'] == span['bbox']:
-                    # 创建table_body_block
-                    table_body_block = make_body_block(
-                        span, table_block['table_body_bbox'],
-                        BlockType.TableBody)
-                    block['blocks'].append(table_body_block)
-
-                    # 从spans中移除img_body_block中已经放入的span
-                    block['spans'].remove(span)
-                    break
-
-            # 根据list长度，判断table_block中是否有caption
-            if table_block['table_caption_bbox'] is not None:
-                table_caption_block, table_caption_spans = merge_spans_to_block(
-                    block['spans'], table_block['table_caption_bbox'],
-                    BlockType.TableCaption)
-                block['blocks'].append(table_caption_block)
-
-                # 如果table_caption_block_spans不为空
-                if len(table_caption_spans) > 0:
-                    #  一些span已经放入了caption_block中，需要从block['spans']中删除
-                    for span in table_caption_spans:
-                        block['spans'].remove(span)
-
-            # 根据list长度，判断table_block中是否有table_note
-            if table_block['table_footnote_bbox'] is not None:
-                table_footnote_block, table_footnote_spans = merge_spans_to_block(
-                    block['spans'], table_block['table_footnote_bbox'],
-                    BlockType.TableFootnote)
-                block['blocks'].append(table_footnote_block)
-
-            break
-    del block['spans']
-    return block
-
-
 def fix_text_block(block):
     # 文本block中的公式span都应该转换成行内type
     for span in block['spans']:

magic_pdf/pre_proc/ocr_span_list_modify.py

@@ -1,10 +1,7 @@
 
 from magic_pdf.config.drop_tag import DropTag
-from magic_pdf.config.ocr_content_type import BlockType, ContentType
-from magic_pdf.libs.boxbase import (__is_overlaps_y_exceeds_threshold,
-                                    calculate_iou,
-                                    calculate_overlap_area_in_bbox1_area_ratio,
-                                    get_minbox_if_overlap_by_ratio)
+from magic_pdf.config.ocr_content_type import BlockType
+from magic_pdf.libs.boxbase import calculate_iou, get_minbox_if_overlap_by_ratio
 
 
 def remove_overlaps_low_confidence_spans(spans):
@@ -59,253 +56,6 @@ def remove_overlaps_min_spans(spans):
     return spans, dropped_spans
 
 
-def remove_spans_by_bboxes(spans, need_remove_spans_bboxes):
-    # 遍历spans, 判断是否在removed_span_block_bboxes中
-    # 如果是, 则删除该span 否则, 保留该span
-    need_remove_spans = []
-    for span in spans:
-        for removed_bbox in need_remove_spans_bboxes:
-            if (
-                calculate_overlap_area_in_bbox1_area_ratio(span['bbox'], removed_bbox)
-                > 0.5
-            ):
-                if span not in need_remove_spans:
-                    need_remove_spans.append(span)
-                    break
-
-    if len(need_remove_spans) > 0:
-        for span in need_remove_spans:
-            spans.remove(span)
-
-    return spans
-
-
-def remove_spans_by_bboxes_dict(spans, need_remove_spans_bboxes_dict):
-    dropped_spans = []
-    for drop_tag, removed_bboxes in need_remove_spans_bboxes_dict.items():
-        # logger.info(f"remove spans by bbox dict, drop_tag: {drop_tag}, removed_bboxes: {removed_bboxes}")
-        need_remove_spans = []
-        for span in spans:
-            # 通过判断span的bbox是否在removed_bboxes中, 判断是否需要删除该span
-            for removed_bbox in removed_bboxes:
-                if (
-                    calculate_overlap_area_in_bbox1_area_ratio(
-                        span['bbox'], removed_bbox
-                    )
-                    > 0.5
-                ):
-                    need_remove_spans.append(span)
-                    break
-                # 当drop_tag为DropTag.FOOTNOTE时, 判断span是否在removed_bboxes中任意一个的下方，如果是,则删除该span
-                elif (
-                    drop_tag == DropTag.FOOTNOTE
-                    and (span['bbox'][1] + span['bbox'][3]) / 2 > removed_bbox[3]
-                    and removed_bbox[0]
-                    < (span['bbox'][0] + span['bbox'][2]) / 2
-                    < removed_bbox[2]
-                ):
-                    need_remove_spans.append(span)
-                    break
-
-        for span in need_remove_spans:
-            spans.remove(span)
-            span['tag'] = drop_tag
-            dropped_spans.append(span)
-
-    return spans, dropped_spans
-
-
-def adjust_bbox_for_standalone_block(spans):
-    # 对tpye=["interline_equation", "image", "table"]进行额外处理,如果左边有字的话,将该span的bbox中y0调整至不高于文字的y0
-    for sb_span in spans:
-        if sb_span['type'] in [
-            ContentType.InterlineEquation,
-            ContentType.Image,
-            ContentType.Table,
-        ]:
-            for text_span in spans:
-                if text_span['type'] in [ContentType.Text, ContentType.InlineEquation]:
-                    # 判断span2的纵向高度是否被span所覆盖
-                    if (
-                        sb_span['bbox'][1] < text_span['bbox'][1]
-                        and sb_span['bbox'][3] > text_span['bbox'][3]
-                    ):
-                        # 判断span2是否在span左边
-                        if text_span['bbox'][0] < sb_span['bbox'][0]:
-                            # 调整span的y0和span2的y0一致
-                            sb_span['bbox'][1] = text_span['bbox'][1]
-    return spans
-
-
-def modify_y_axis(spans: list, displayed_list: list, text_inline_lines: list):
-    # displayed_list = []
-    # 如果spans为空,则不处理
-    if len(spans) == 0:
-        pass
-    else:
-        spans.sort(key=lambda span: span['bbox'][1])
-
-        lines = []
-        current_line = [spans[0]]
-        if spans[0]['type'] in [
-            ContentType.InterlineEquation,
-            ContentType.Image,
-            ContentType.Table,
-        ]:
-            displayed_list.append(spans[0])
-
-        line_first_y0 = spans[0]['bbox'][1]
-        line_first_y = spans[0]['bbox'][3]
-        # 用于给行间公式搜索
-        # text_inline_lines = []
-        for span in spans[1:]:
-            # if span.get("content","") == "78.":
-            #     print("debug")
-            # 如果当前的span类型为"interline_equation" 或者 当前行中已经有"interline_equation"
-            # image和table类型，同上
-            if span['type'] in [
-                ContentType.InterlineEquation,
-                ContentType.Image,
-                ContentType.Table,
-            ] or any(
-                s['type']
-                in [ContentType.InterlineEquation, ContentType.Image, ContentType.Table]
-                for s in current_line
-            ):
-                # 传入
-                if span['type'] in [
-                    ContentType.InterlineEquation,
-                    ContentType.Image,
-                    ContentType.Table,
-                ]:
-                    displayed_list.append(span)
-                # 则开始新行
-                lines.append(current_line)
-                if len(current_line) > 1 or current_line[0]['type'] in [
-                    ContentType.Text,
-                    ContentType.InlineEquation,
-                ]:
-                    text_inline_lines.append(
-                        (current_line, (line_first_y0, line_first_y))
-                    )
-                current_line = [span]
-                line_first_y0 = span['bbox'][1]
-                line_first_y = span['bbox'][3]
-                continue
-
-            # 如果当前的span与当前行的最后一个span在y轴上重叠，则添加到当前行
-            if __is_overlaps_y_exceeds_threshold(
-                span['bbox'], current_line[-1]['bbox']
-            ):
-                if span['type'] == 'text':
-                    line_first_y0 = span['bbox'][1]
-                    line_first_y = span['bbox'][3]
-                current_line.append(span)
-
-            else:
-                # 否则，开始新行
-                lines.append(current_line)
-                text_inline_lines.append((current_line, (line_first_y0, line_first_y)))
-                current_line = [span]
-                line_first_y0 = span['bbox'][1]
-                line_first_y = span['bbox'][3]
-
-            # 添加最后一行
-        if current_line:
-            lines.append(current_line)
-            if len(current_line) > 1 or current_line[0]['type'] in [
-                ContentType.Text,
-                ContentType.InlineEquation,
-            ]:
-                text_inline_lines.append((current_line, (line_first_y0, line_first_y)))
-        for line in text_inline_lines:
-            # 按照x0坐标排序
-            current_line = line[0]
-            current_line.sort(key=lambda span: span['bbox'][0])
-
-        # 调整每一个文字行内bbox统一
-        for line in text_inline_lines:
-            current_line, (line_first_y0, line_first_y) = line
-            for span in current_line:
-                span['bbox'][1] = line_first_y0
-                span['bbox'][3] = line_first_y
-
-        # return spans, displayed_list, text_inline_lines
-
-
-def modify_inline_equation(spans: list, displayed_list: list, text_inline_lines: list):
-    # 错误行间公式转行内公式
-    j = 0
-    for i in range(len(displayed_list)):
-        # if i == 8:
-        #     print("debug")
-        span = displayed_list[i]
-        span_y0, span_y = span['bbox'][1], span['bbox'][3]
-
-        while j < len(text_inline_lines):
-            text_line = text_inline_lines[j]
-            y0, y1 = text_line[1]
-            if (
-                span_y0 < y0 < span_y
-                or span_y0 < y1 < span_y
-                or span_y0 < y0
-                and span_y > y1
-            ) and __is_overlaps_y_exceeds_threshold(span['bbox'], (0, y0, 0, y1)):
-                # 调整公式类型
-                if span['type'] == ContentType.InterlineEquation:
-                    # 最后一行是行间公式
-                    if j + 1 >= len(text_inline_lines):
-                        span['type'] = ContentType.InlineEquation
-                        span['bbox'][1] = y0
-                        span['bbox'][3] = y1
-                    else:
-                        # 行间公式旁边有多行文字或者行间公式比文字高3倍则不转换
-                        y0_next, y1_next = text_inline_lines[j + 1][1]
-                        if (
-                            not __is_overlaps_y_exceeds_threshold(
-                                span['bbox'], (0, y0_next, 0, y1_next)
-                            )
-                            and 3 * (y1 - y0) > span_y - span_y0
-                        ):
-                            span['type'] = ContentType.InlineEquation
-                            span['bbox'][1] = y0
-                            span['bbox'][3] = y1
-                break
-            elif (
-                span_y < y0
-                or span_y0 < y0 < span_y
-                and not __is_overlaps_y_exceeds_threshold(span['bbox'], (0, y0, 0, y1))
-            ):
-                break
-            else:
-                j += 1
-
-    return spans
-
-
-def get_qa_need_list(blocks):
-    # 创建 images, tables, interline_equations, inline_equations 的副本
-    images = []
-    tables = []
-    interline_equations = []
-    inline_equations = []
-
-    for block in blocks:
-        for line in block['lines']:
-            for span in line['spans']:
-                if span['type'] == ContentType.Image:
-                    images.append(span)
-                elif span['type'] == ContentType.Table:
-                    tables.append(span)
-                elif span['type'] == ContentType.InlineEquation:
-                    inline_equations.append(span)
-                elif span['type'] == ContentType.InterlineEquation:
-                    interline_equations.append(span)
-                else:
-                    continue
-    return images, tables, interline_equations, inline_equations
-
-
 def get_qa_need_list_v2(blocks):
     # 创建 images, tables, interline_equations, inline_equations 的副本
     images = []

magic_pdf/rw/S3ReaderWriter.py

@@ -1,5 +1,5 @@
 from magic_pdf.rw.AbsReaderWriter import AbsReaderWriter
-from magic_pdf.libs.commons import parse_aws_param, parse_bucket_key, join_path
+from magic_pdf.libs.commons import parse_bucket_key, join_path
 import boto3
 from loguru import logger
 from botocore.config import Config

{magic_pdf-0.10.0.dist-info → magic_pdf-0.10.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: magic-pdf
-Version: 0.10.0
+Version: 0.10.2
 Summary: A practical tool for converting PDF to Markdown
 Home-page: https://github.com/opendatalab/MinerU
 Requires-Python: >=3.9
@@ -320,88 +320,14 @@ If your device supports CUDA and meets the GPU requirements of the mainline envi
 
 ### Command Line
 
-```bash
-magic-pdf --help
-Usage: magic-pdf [OPTIONS]
-
-Options:
-  -v, --version                display the version and exit
-  -p, --path PATH              local pdf filepath or directory  [required]
-  -o, --output-dir PATH        output local directory  [required]
-  -m, --method [ocr|txt|auto]  the method for parsing pdf. ocr: using ocr
-                               technique to extract information from pdf. txt:
-                               suitable for the text-based pdf only and
-                               outperform ocr. auto: automatically choose the
-                               best method for parsing pdf from ocr and txt.
-                               without method specified, auto will be used by
-                               default.
-  -l, --lang TEXT              Input the languages in the pdf (if known) to
-                               improve OCR accuracy.  Optional. You should
-                               input "Abbreviation" with language form url: ht
-                               tps://paddlepaddle.github.io/PaddleOCR/latest/en
-                               /ppocr/blog/multi_languages.html#5-support-languages-
-                               and-abbreviations
-  -d, --debug BOOLEAN          Enables detailed debugging information during
-                               the execution of the CLI commands.
-  -s, --start INTEGER          The starting page for PDF parsing, beginning
-                               from 0.
-  -e, --end INTEGER            The ending page for PDF parsing, beginning from
-                               0.
-  --help                       Show this message and exit.
-
-
-## show version
-magic-pdf -v
-
-## command line example
-magic-pdf -p {some_pdf} -o {some_output_dir} -m auto
-```
+[Using MinerU via Command Line](https://mineru.readthedocs.io/en/latest/user_guide/quick_start/command_line.html)
 
-`{some_pdf}` can be a single PDF file or a directory containing multiple PDFs.
-The results will be saved in the `{some_output_dir}` directory. The output file list is as follows:
-
-```text
-├── some_pdf.md                          # markdown file
-├── images                               # directory for storing images
-├── some_pdf_layout.pdf                  # layout diagram (Include layout reading order)
-├── some_pdf_middle.json                 # MinerU intermediate processing result
-├── some_pdf_model.json                  # model inference result
-├── some_pdf_origin.pdf                  # original PDF file
-├── some_pdf_spans.pdf                   # smallest granularity bbox position information diagram
-└── some_pdf_content_list.json           # Rich text JSON arranged in reading order
-```
 > [!TIP]
 > For more information about the output files, please refer to the [Output File Description](docs/output_file_en_us.md).
 
 ### API
 
-Processing files from local disk
-
-```python
-image_writer = DiskReaderWriter(local_image_dir)
-image_dir = str(os.path.basename(local_image_dir))
-jso_useful_key = {"_pdf_type": "", "model_list": []}
-pipe = UNIPipe(pdf_bytes, jso_useful_key, image_writer)
-pipe.pipe_classify()
-pipe.pipe_analyze()
-pipe.pipe_parse()
-md_content = pipe.pipe_mk_markdown(image_dir, drop_mode="none")
-```
-
-Processing files from object storage
-
-```python
-s3pdf_cli = S3ReaderWriter(pdf_ak, pdf_sk, pdf_endpoint)
-image_dir = "s3://img_bucket/"
-s3image_cli = S3ReaderWriter(img_ak, img_sk, img_endpoint, parent_path=image_dir)
-pdf_bytes = s3pdf_cli.read(s3_pdf_path, mode=s3pdf_cli.MODE_BIN)
-jso_useful_key = {"_pdf_type": "", "model_list": []}
-pipe = UNIPipe(pdf_bytes, jso_useful_key, s3image_cli)
-pipe.pipe_classify()
-pipe.pipe_analyze()
-pipe.pipe_parse()
-md_content = pipe.pipe_mk_markdown(image_dir, drop_mode="none")
-```
+[Using MinerU via Python API](https://mineru.readthedocs.io/en/latest/user_guide/quick_start/to_markdown.html)
 
 For detailed implementation, refer to: