图片内置在md文件内，用base64内置。

[pmiscn]

Is your feature request related to a problem? Please describe.
提取的图片，希望内置在markdown文件内，而不是外部文件
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
比如，生成下面的图片。

比如加上参数 --image=base64 参数实现。

[zhoumanchao]

换成url地址吧。我给你修改后的代码，你试试
import base64
import json
import os
import tempfile
import time
from pathlib import Path
from typing import Tuple, Union

from fastapi import FastAPI, UploadFile, File, HTTPException
from loguru import logger
from minio import Minio
from openai import OpenAI

from magic_pdf.config.enums import SupportedPdfParseMethod
from magic_pdf.data.data_reader_writer import FileBasedDataWriter, FileBasedDataReader
from magic_pdf.data.dataset import PymuDocDataset
from magic_pdf.model.doc_analyze_by_custom_model import doc_analyze

初始化FastAPI应用

app = FastAPI()

def load_config():
"""从用户目录加载并验证配置文件"""
home_dir = str(Path.home())
config_path = os.path.join(home_dir, 'magic-pdf.json')

try:
    with open(config_path, 'r') as f:
        config = json.load(f)

    # 验证One-API配置
    if 'one_api' not in config:
        raise ValueError("配置文件中缺少One-API配置")
    required_keys = ['api_base', 'api_key', 'model_name']
    for key in required_keys:
        if key not in config['one_api']:
            raise ValueError(f"One-API配置缺少必要参数: {key}")

    # 验证MinIO配置
    if 'bucket_info' not in config or not config['bucket_info']:
        raise ValueError("配置文件中缺少MinIO配置")

    return config

except FileNotFoundError:
    raise FileNotFoundError(f"未找到配置文件: {config_path}")
except json.JSONDecodeError:
    raise ValueError("配置文件格式错误，不是有效的JSON格式")
except Exception as e:
    raise RuntimeError(f"加载配置文件失败: {str(e)}")

def init_minio_client(config: dict) -> Tuple[Minio, str]:
"""初始化MinIO客户端并确保存储桶存在"""
bucket_name = list(config['bucket_info'].keys())[0]
bucket_info = config['bucket_info'][bucket_name]
access_key = bucket_info[0]
secret_key = bucket_info[1]
endpoint = bucket_info[2].replace("http://", "").replace("https://", "")

client = Minio(
    endpoint,
    access_key=access_key,
    secret_key=secret_key,
    secure=False
)

full_bucket_name = f"{access_key}-{bucket_name}"

try:
    if not client.bucket_exists(full_bucket_name):
        client.make_bucket(full_bucket_name)
        logger.info(f"创建存储桶：{full_bucket_name}")
    return client, full_bucket_name
except Exception as e:
    logger.error(f"MinIO初始化失败: {str(e)}")
    raise

def upload_to_minio(client: Minio, bucket_name: str, file_path: str, object_name: str, config: dict) -> str:
"""上传文件到MinIO并返回完整URL"""
try:
endpoint_url = config['bucket_info'][list(config['bucket_info'].keys())[0]][2]
if not endpoint_url.startswith(("http://", "https://")):
endpoint_url = f"http://{endpoint_url}"

    content_type = 'text/markdown' if object_name.endswith('.md') else 'image/jpeg'

    # 添加时间戳防止文件名冲突
    file_ext = os.path.splitext(object_name)[1]
    file_base = os.path.splitext(object_name)[0]
    timestamp = int(time.time() * 1000)
    unique_name = f"{file_base}_{timestamp}{file_ext}"

    client.fput_object(
        bucket_name,
        unique_name,
        file_path,
        content_type=content_type
    )

    return f"{endpoint_url}/{bucket_name}/{unique_name}"
except Exception as e:
    logger.error(f"文件上传失败: {str(e)}")
    raise HTTPException(status_code=500, detail="文件上传失败")

def generate_image_caption(image_path: str, config: dict) -> str:
"""使用OpenAI API生成图片标题"""
try:
client = OpenAI(
api_key=config['one_api']['api_key'],
base_url=config['one_api']['api_base']
)

    with open(image_path, "rb") as image_file:
        image_data = base64.b64encode(image_file.read()).decode('utf-8')

    response = client.chat.completions.create(
        model=config['one_api']['model_name'],
        messages=[
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "根据这张图片，生成一个合适的标题，不要包含任何符号和引号"},
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/jpeg;base64,{image_data}"
                        }
                    }
                ]
            }
        ],
        max_tokens=512
    )

    caption = response.choices[0].message.content.strip()
    for char in ['"', "'", "[", "]", "(", ")"]:
        caption = caption.replace(char, "")
    return caption.strip()
except Exception as e:
    logger.error(f"标题生成失败: {str(e)}")
    return "图片内容"

async def process_pdf_file(pdf_path: str, output_dir: str, minio_client: Minio,
bucket_name: str, config: dict, generate_captions: bool = True):
"""处理PDF文件并返回解析结果"""
global content
try:
file_name = os.path.splitext(os.path.basename(pdf_path))[0]
logger.info(f"开始处理PDF文件: {pdf_path}")

    # 读取并解析PDF
    reader = FileBasedDataReader("")
    pdf_bytes = reader.read(pdf_path)
    ds = PymuDocDataset(pdf_bytes)

    # 创建输出目录
    local_image_dir = os.path.join(output_dir, "images")
    os.makedirs(local_image_dir, exist_ok=True)
    image_writer = FileBasedDataWriter(local_image_dir)

    # 根据PDF类型处理
    if ds.classify() == SupportedPdfParseMethod.OCR:
        logger.info("使用OCR模式处理PDF")
        infer_result = ds.apply(doc_analyze, ocr=True)
        pipe_result = infer_result.pipe_ocr_mode(image_writer)
    else:
        logger.info("使用文本模式处理PDF")
        infer_result = ds.apply(doc_analyze, ocr=False)
        pipe_result = infer_result.pipe_txt_mode(image_writer)

    # 处理图片
    image_urls = []
    image_captions = {}
    for img_file in os.listdir(local_image_dir):
        if img_file.lower().endswith(('.png', '.jpg', '.jpeg')):
            img_path = os.path.join(local_image_dir, img_file)

            # 生成标题（如果启用）
            caption = generate_image_caption(img_path, config) if generate_captions else "图片内容"
            image_captions[img_file] = caption
            logger.info(f"图片标题生成: {img_file} -> {caption}")

            # 上传图片到MinIO
            object_name = f"documents/{file_name}/images/{img_file}"
            url = upload_to_minio(minio_client, bucket_name, img_path, object_name, config)
            image_urls.append(url)
            logger.debug(f"图片上传成功，URL: {url}")

    # 生成Markdown内容
    md_file = f"{file_name}.md"
    md_writer = FileBasedDataWriter(output_dir)
    pipe_result.dump_md(md_writer, md_file, "images")

    # 读取并更新Markdown内容
    md_path = os.path.join(output_dir, md_file)
    with open(md_path, "r", encoding="utf-8") as f:
        content = f.read()

    # 替换图片引用
    for img_file, url in zip(os.listdir(local_image_dir), image_urls):
        if img_file.lower().endswith(('.png', '.jpg', '.jpeg')):
            caption = image_captions.get(img_file, "图片内容")
            new_content = f"![{caption}]({url})"
            content = content.replace(f"![](images/{img_file})", new_content)

    # 保存更新后的Markdown
    with open(md_path, "w", encoding="utf-8") as f:
        f.write(content)

    # 上传Markdown到MinIO
    md_object_name = f"documents/{file_name}/{md_file}"
    md_url = upload_to_minio(minio_client, bucket_name, md_path, md_object_name, config)

    return {
        "content": content,
        "markdown_url": md_url,
        "status": "success"
    }
except Exception as e:
    logger.error(f"PDF处理失败: {str(e)}", exc_info=True)
    raise HTTPException(status_code=500, detail=f"PDF处理失败: {str(e)}")

async def process_uploaded_file(file: UploadFile, minio_client: Minio,
bucket_name: str, config: dict, generate_captions: bool = False):
"""处理上传的文件并返回解析结果"""
with tempfile.TemporaryDirectory() as temp_dir:
# 保存上传文件
file_path = os.path.join(temp_dir, file.filename)
with open(file_path, "wb") as f:
f.write(await file.read())

    # 根据文件类型处理
    file_ext = os.path.splitext(file.filename)[1].lower()
    output_dir = os.path.join(temp_dir, "output")
    os.makedirs(output_dir, exist_ok=True)

    if file_ext == ".pdf":
        return await process_pdf_file(file_path, output_dir, minio_client, bucket_name, config, generate_captions)
    elif file_ext in [".doc", ".docx", ".ppt", ".pptx"]:
        raise HTTPException(status_code=400, detail="Office文件处理功能暂未实现")
    elif file_ext in [".jpg", ".jpeg", ".png"]:
        raise HTTPException(status_code=400, detail="图片文件处理功能暂未实现")
    else:
        raise HTTPException(status_code=400, detail="不支持的文件类型")

服务初始化

try:
config = load_config()
minio_client, bucket_name = init_minio_client(config)
logger.success(f"服务初始化完成，配置文件位置: {str(Path.home())}/magic-pdf.json")
except Exception as e:
logger.critical(f"初始化失败: {str(e)}")
raise

@app.post("/parse")
async def parse_file(file: UploadFile = File(...), generate_captions: bool = False):
"""文件解析接口"""
try:
return await process_uploaded_file(file, minio_client, bucket_name, config, generate_captions)
except HTTPException:
raise
except Exception as e:
logger.error(f"处理失败: {str(e)}")
raise HTTPException(status_code=500, detail="文件处理失败")

if name == "main":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)