conda create -n mineru pythnotallow=3.10 
conda activate mineru
pip install uv -i https://mirrors.aliyun.com/pypi/simple
uv pip install -U "mineru[core]" -i https://mirrors.aliyun.com/pypi/simple

python mineru/cli/models_download.py

方法二：使用交互式命令行工具選擇模型下載：

mineru-models-download

詳細參考如何下載模型文件2.配置文件
詳細參考如何下載模型文件
2.配置文件

output/
  ├── [PDF文件名]/
  │   ├── images/            # 存放提取的圖片
  │   ├── [PDF文件名].md     # 生成的Markdown文件
  │   ├── [PDF文件名]_origin.pdf  # 原始 PDF 文件（完整模式）
  │   ├── [PDF文件名]_content_list.json  # 內容列表JSON文件
  │   ├── [PDF文件名]_model.pdf   # 模型可視化結果（完整模式）
  │   ├── [PDF文件名]_middle.pdf   # 模型中間處理結果（完整模式）
  │   ├── [PDF文件名]_layout.pdf  # 布局可視化結果（完整模式）
  │   └── [PDF文件名]_spans.pdf   # 文本塊可視化結果（完整模式）

import os
os.environ['MINERU_MODEL_SOURCE'] = "local"
from pathlib import Path
from loguru import logger
from mineru.cli.common import convert_pdf_bytes_to_bytes_by_pypdfium2, prepare_env, read_fn
from mineru.data.data_reader_writer import FileBasedDataWriter
from mineru.utils.draw_bbox import draw_layout_bbox, draw_span_bbox
from mineru.utils.enum_class import MakeMode
from mineru.backend.vlm.vlm_analyze import doc_analyze as vlm_doc_analyze
from mineru.backend.pipeline.pipeline_analyze import doc_analyze as pipeline_doc_analyze
from mineru.backend.pipeline.pipeline_middle_json_mkcontent import union_make as pipeline_union_make
from mineru.backend.pipeline.model_json_to_middle_json import result_to_middle_json as pipeline_result_to_middle_json
from mineru.backend.vlm.vlm_middle_json_mkcontent import union_make as vlm_union_make
def process_pdf(pdf_file_name, output_dir="output", image_subdir="images", simple_output=True, backend="pipeline", method="auto", lang="ch", server_url=None, start_page_id=0, end_page_id=None):
    """
    處理PDF文件，將其轉換為Markdown格式并保存相關資源
    :param pdf_file_name: PDF文件名
    :param output_dir: 輸出目錄，默認為'output'
    :param image_subdir: 圖片子目錄名，默認為'images'
    :param simple_output: 是否使用簡單輸出模式，默認為False
    :param backend: 解析PDF的后端，默認為'pipeline'
    :param method: 解析PDF的方法，默認為'auto'
    :param lang: 輸入PDF中的語言，默認為'ch'
    :param server_url: 當后端為`vlm-sglang-client`時需要指定的服務器URL
    :param start_page_id: 解析的起始頁碼，默認為0
    :param end_page_id: 解析的結束頁碼，默認為None
    """
    # 獲取不帶后綴的文件名
    name_without_suff = os.path.splitext(os.path.basename(pdf_file_name))[0]
    # 構建圖片目錄和markdown目錄的路徑
    local_image_dir = os.path.join(output_dir, output_subdir, image_subdir)
    local_md_dir = output_dir
    # 創建必要的目錄
    os.makedirs(local_image_dir, exist_ok=True)
    os.makedirs(local_md_dir, exist_ok=True)
    # 創建文件寫入器
    image_writer, md_writer = FileBasedDataWriter(local_image_dir), FileBasedDataWriter(local_md_dir)
    # 讀取PDF文件
    pdf_bytes = read_fn(pdf_file_name)
    pdf_file_names = [name_without_suff]
    pdf_bytes_list = [pdf_bytes]
    p_lang_list = [lang]
    if backend == "pipeline":
        new_pdf_bytes = convert_pdf_bytes_to_bytes_by_pypdfium2(pdf_bytes, start_page_id, end_page_id)
        pdf_bytes_list[0] = new_pdf_bytes
        infer_results, all_image_lists, all_pdf_docs, lang_list, ocr_enabled_list = pipeline_doc_analyze(pdf_bytes_list, p_lang_list, parse_method=method, formula_enable=True, table_enable=True)
        model_list = infer_results[0]
        model_json = model_list.copy()
        images_list = all_image_lists[0]
        pdf_doc = all_pdf_docs[0]
        _lang = lang_list[0]
        _ocr_enable = ocr_enabled_list[0]
        middle_json = pipeline_result_to_middle_json(model_list, images_list, pdf_doc, image_writer, _lang, _ocr_enable, True)
        pdf_info = middle_json["pdf_info"]
        pdf_bytes = pdf_bytes_list[0]
        # 生成Markdown文件和內容列表（無論哪種模式都需要）
        md_content_str = pipeline_union_make(pdf_info, MakeMode.MM_MD, image_dir)
        md_writer.write_string(
            f"{name_without_suff}.md",
            md_content_str,
        )
        content_list = pipeline_union_make(pdf_info, MakeMode.CONTENT_LIST, image_dir)
        md_writer.write_string(
            f"{name_without_suff}_content_list.json",
            str(content_list),
        )


        # 僅在完整輸出模式下生成額外文件
        if not simple_output:
            # 生成布局可視化文件
            draw_layout_bbox(pdf_info, pdf_bytes, local_md_dir, f"{name_without_suff}_layout.pdf")


            # 生成文本塊可視化文件
            draw_span_bbox(pdf_info, pdf_bytes, local_md_dir, f"{name_without_suff}_span.pdf")


            # 保存原始PDF文件
            md_writer.write(
                f"{name_without_suff}_origin.pdf",
                pdf_bytes,
            )


            # 保存中間JSON和模型輸出
            md_writer.write_string(
                f"{name_without_suff}_middle.json",
                str(middle_json),
            )
            md_writer.write_string(
                f"{name_without_suff}_model.json",
                str(model_json),
            )


        logger.info(f"local output dir is {local_md_dir}")
    else:
        if backend.startswith("vlm-"):
            backend = backend[4:]
        f_draw_span_bbox = False
        parse_method = "vlm"
        pdf_bytes = convert_pdf_bytes_to_bytes_by_pypdfium2(pdf_bytes, start_page_id, end_page_id)
        middle_json, infer_result = vlm_doc_analyze(pdf_bytes, image_writer=image_writer, backend=backend, server_url=server_url)
        pdf_info = middle_json["pdf_info"]
        if not simple_output:
            if True:
                draw_layout_bbox(pdf_info, pdf_bytes, local_md_dir, f"{name_without_suff}_layout.pdf")
            if f_draw_span_bbox:
                draw_span_bbox(pdf_info, pdf_bytes, local_md_dir, f"{name_without_suff}_span.pdf")
            if True:
                md_writer.write(
                    f"{name_without_suff}_origin.pdf",
                    pdf_bytes,
                )
        image_dir = str(os.path.basename(local_image_dir))
        if simple_output:
            # 簡單輸出模式：只輸出markdown和內容列表
            md_content_str = vlm_union_make(pdf_info, MakeMode.MM_MD, image_dir)
            md_writer.write_string(
                f"{name_without_suff}.md",
                md_content_str,
            )
            content_list = vlm_union_make(pdf_info, MakeMode.CONTENT_LIST, image_dir)
            md_writer.write_string(
                f"{name_without_suff}_content_list.json",
                str(content_list),
            )
        else:
            # 完整輸出模式：輸出所有內容
            md_content_str = vlm_union_make(pdf_info, MakeMode.MM_MD, image_dir)
            md_writer.write_string(
                f"{name_without_suff}.md",
                md_content_str,
            )
            content_list = vlm_union_make(pdf_info, MakeMode.CONTENT_LIST, image_dir)
            md_writer.write_string(
                f"{name_without_suff}_content_list.json",
                str(content_list),
            )
            md_writer.write_string(
                f"{name_without_suff}_middle.json",
                str(middle_json),
            )
            model_output = ("\n" + "-" * 50 + "\n").join(infer_result)
            md_writer.write_string(
                f"{name_without_suff}_model_output.txt",
                model_output,
            )
        logger.info(f"local output dir is {local_md_dir}")
    # 構建markdown文件的完整路徑
    md_file_path = os.path.join(os.getcwd(), local_md_dir, f"{name_without_suff}.md")
    abs_md_file_path = os.path.abspath(md_file_path)
    return abs_md_file_path
if __name__ == "__main__":
    # 指定要處理的PDF文件名
    pdf_file_name = "/home/MinerU/demo/pdfs/demo1.pdf"
    # 處理PDF文件并獲取生成的markdown文件路徑
    md_file_path = process_pdf(pdf_file_name, output_dir="/home/MinerU/demo/output", simple_output=False, backend="pipeline")
    # 打印生成的markdown文件路徑
    print(md_file_path)

from flask import Flask, request, send_file, jsonify
import os
os.environ['MINERU_MODEL_SOURCE'] = "local"
import shutil
import zipfile
from scripts.process_pdf import process_pdf
from pathlib import Path
from mineru.cli.common import read_fn, pdf_suffixes, image_suffixes
app = Flask(__name__)
def create_zip_from_directory(directory_path, zip_file_path):
    with zipfile.ZipFile(zip_file_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
        for root, dirs, files in os.walk(directory_path):
            for file in files:
                file_path = os.path.join(root, file)
                arcname = os.path.relpath(file_path, directory_path)
                zipf.write(file_path, arcname)
@app.route('/process_file', methods=['POST'])
def process_file_api():
    # 檢查請求中是否包含文件
    if 'file' not in request.files:
        return jsonify({'error': 'No file part'}), 400
    file = request.files['file']
    if file.filename == '':
        return jsonify({'error': 'No selected file'}), 400
    file_path = Path(file.filename)
    # 檢查文件類型是否支持
    if file_path.suffix.lower() not in pdf_suffixes + image_suffixes:
        return jsonify({'error': f"Unsupported file type: {file_path.suffix}"}), 400
    # 獲取文件名（不含擴展名）用于創建子文件夾
    file_stem = file_path.stem


    # 創建以文件名命名的臨時子文件夾
    temp_subdir = os.path.join('temp', file_stem)
    os.makedirs(temp_subdir, exist_ok=True)


    # 保存上傳的文件到臨時子文件夾
    input_file_path = os.path.join(temp_subdir, file.filename)
    file.save(input_file_path)
    try:
        # 讀取文件內容
        pdf_bytes = read_fn(input_file_path)
        # 僅當輸入不是PDF時，保存轉換后的PDF
        temp_pdf_path = None
        if file_path.suffix.lower() not in pdf_suffixes:
            temp_pdf_path = os.path.join(temp_subdir, f"{file_stem}.pdf")
            with open(temp_pdf_path, 'wb') as f:
                f.write(pdf_bytes)
        else:
            # 輸入是PDF，直接使用原文件路徑
            temp_pdf_path = input_file_path
        # 處理文件
        markdown_file_path = process_pdf(
            temp_pdf_path,
            output_dir=temp_subdir,
        )
        # 直接在temp_subdir下創建ZIP文件
        name_without_suff = os.path.splitext(os.path.basename(input_file_path))[0]
        zip_file_path = os.path.join(temp_subdir, f"{name_without_suff}.zip")
        create_zip_from_directory(temp_subdir, zip_file_path)
        # 發送ZIP文件作為響應
        return send_file(zip_file_path, as_attachment=True)
    except Exception as e:
        return jsonify({'error': str(e)}), 500
    finally:
        # 僅清理ZIP文件，保留其他臨時文件
        if os.path.exists(zip_file_path):
            os.remove(zip_file_path)
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=6601)

import requests
import os
import zipfile
import io
def parse_pdf_api_to_path(pdf_file_path, output_dir):
    url = "http://localhost:6601/process_pdf"
    # 確保輸出目錄存在
    os.makedirs(output_dir, exist_ok=True)
    # 獲取 PDF 文件的基礎名稱（不帶擴展名）
    base_filename = os.path.splitext(os.path.basename(pdf_file_path))[0]
    with open(pdf_file_path, 'rb') as pdf_file:
        files = {'pdf_file': pdf_file}
        response = requests.post(url, files=files)
    if response.status_code == 200:
        # 保存返回的 zip 文件到指定目錄，使用與 PDF 相同的基礎文件名
        output_zip_path = os.path.join(output_dir, f'{base_filename}.zip')
        with open(output_zip_path, 'wb') as f:
            f.write(response.content)
        print(f"Test passed: Received zip file and saved to {output_zip_path}.")
    else:
        print(f"Test failed: {response.status_code} - {response.json()}")
def parse_pdf_api_to_content(pdf_file_path):
    url = "http://localhost:6601/process_pdf"
    # 獲取 PDF 文件的基礎名稱（不帶擴展名）
    base_filename = os.path.splitext(os.path.basename(pdf_file_path))[0]
    with open(pdf_file_path, 'rb') as pdf_file:
        files = {'pdf_file': pdf_file}
        response = requests.post(url, files=files)
    if response.status_code == 200:
        # 返回壓縮包內容
        print(f"Request successful: Received zip file for {base_filename}.")
        return response.content
    else:
        error_message = f"Request failed: {response.status_code} - {response.json()}"
        print(error_message)
        raise Exception(error_message)
def save_zip_content_to_directory(zip_content, output_dir):
    # 確保輸出目錄存在
    os.makedirs(output_dir, exist_ok=True)
    # 使用 zipfile 模塊解壓縮內容
    with zipfile.ZipFile(io.BytesIO(zip_content)) as z:
        z.extractall(output_dir)
    print(f"Files extracted to {output_dir}")
def save_zip_and_content_to_directory(zip_content, output_dir, zip_filename):
    # 確保輸出目錄存在
    os.makedirs(output_dir, exist_ok=True)
    # 保存壓縮包到指定目錄
    zip_path = os.path.join(output_dir, zip_filename)
    with open(zip_path, 'wb') as f:
        f.write(zip_content)
    print(f"Zip file saved to {zip_path}")
    # 使用 zipfile 模塊解壓縮內容
    with zipfile.ZipFile(io.BytesIO(zip_content)) as z:
        z.extractall(output_dir)
    print(f"Files extracted to {output_dir}")
if __name__ == "__main__":
    pdf_file_path = "/path/to/your.pdf"
    output_unzip_dir = "/path/to/output/dir"
    try:
        # 獲取壓縮包內容
        zip_content = parse_pdf_api_to_content(pdf_file_path)
        # 定義壓縮包文件名
        zip_filename = os.path.splitext(os.path.basename(pdf_file_path))[0] + ".zip"
        # 解壓并保存到指定目錄
        # save_zip_content_to_directory(zip_content, output_unzip_dir)
        # 保存壓縮包到指定目錄并解壓
        save_zip_and_content_to_directory(zip_content, output_unzip_dir, zip_filename)
    except Exception as e:
        print(f"An error occurred: {e}")

pdf_file_path = "/path/to/your.pdf"
output_unzip_dir = "/path/to/output/dir"
# 獲取壓縮包內容
zip_content = parse_pdf_api_to_content(pdf_file_path)
# 解壓并保存到指定目錄
save_zip_content_to_directory(zip_content, output_unzip_dir)

pdf_file_path = "/path/to/your.pdf"
output_unzip_dir = "/path/to/output/dir"
# 獲取壓縮包內容
zip_content = parse_pdf_api_to_content(pdf_file_path)
# 定義壓縮包文件名
zip_filename = os.path.splitext(os.path.basename(pdf_file_path))[0] + ".zip"
# 保存壓縮包并解壓
save_zip_and_content_to_directory(zip_content, output_unzip_dir, zip_filename)

pdf_file_path = "/path/to/your.pdf"
output_dir = "/path/to/output/dir"
# 直接調用API并將結果保存到指定目錄
parse_pdf_api_to_path(pdf_file_path, output_dir)