mineru 2.7.3__py3-none-any.whl → 2.7.5__py3-none-any.whl

mineru/backend/pipeline/model_init.py

@@ -297,7 +297,14 @@ def ocr_det_batch_setting(device):
     # 检测torch的版本号
     import torch
     from packaging import version
-    if version.parse(torch.__version__) >= version.parse("2.8.0") or str(device).startswith('mps'):
+
+    device_type = os.getenv("MINERU_LMDEPLOY_DEVICE", "")
+
+    if (
+            version.parse(torch.__version__) >= version.parse("2.8.0")
+            or str(device).startswith('mps')
+            or device_type.lower() in ["corex"]
+    ):
         enable_ocr_det_batch = False
     else:
         enable_ocr_det_batch = True

mineru/backend/pipeline/pipeline_analyze.py

@@ -193,7 +193,12 @@ def batch_image_analyze(
     # 检测torch的版本号
     import torch
     from packaging import version
-    if version.parse(torch.__version__) >= version.parse("2.8.0") or str(device).startswith('mps'):
+    device_type = os.getenv("MINERU_LMDEPLOY_DEVICE", "")
+    if (
+            version.parse(torch.__version__) >= version.parse("2.8.0")
+            or str(device).startswith('mps')
+            or device_type.lower() in ["corex"]
+    ):
         enable_ocr_det_batch = False
     else:
         enable_ocr_det_batch = True

mineru/backend/vlm/utils.py

@@ -22,6 +22,8 @@ def enable_custom_logits_processors() -> bool:
         compute_capability = "8.0"
     elif hasattr(torch, 'musa') and torch.musa.is_available():
         compute_capability = "8.0"
+    elif hasattr(torch, 'mlu') and torch.mlu.is_available():
+        compute_capability = "8.0"
     else:
         logger.info("CUDA not available, disabling custom_logits_processors")
         return False

mineru/backend/vlm/vlm_analyze.py

@@ -101,20 +101,27 @@ class ModelSingleton:
                     except ImportError:
                         raise ImportError("Please install vllm to use the vllm-engine backend.")
 
-                    """
                     # musa vllm v1 引擎特殊配置
-                    device = get_device()
-                    if device.startswith("musa"):
-                        import torch
-                        if torch.musa.is_available():
-                            compilation_config = {
-                                "cudagraph_capture_sizes": [1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 18, 20, 24, 28, 30],
-                                "simple_cuda_graph": True
-                            }
-                            block_size = 32
-                            kwargs["compilation_config"] = compilation_config
-                            kwargs["block_size"] = block_size
-                    """
+                    # device = get_device()
+                    # if device_type.startswith("musa"):
+                    #     import torch
+                    #     if torch.musa.is_available():
+                    #         compilation_config = {
+                    #             "cudagraph_capture_sizes": [1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 18, 20, 24, 28, 30],
+                    #             "simple_cuda_graph": True
+                    #         }
+                    #         block_size = 32
+                    #         kwargs["compilation_config"] = compilation_config
+                    #         kwargs["block_size"] = block_size
+
+                    # corex vllm v1 引擎特殊配置
+                    device_type = os.getenv("MINERU_LMDEPLOY_DEVICE", "")
+                    if device_type.lower() == "corex":
+                        compilation_config = {
+                            "cudagraph_mode": "FULL_DECODE_ONLY",
+                            "level": 0
+                        }
+                        kwargs["compilation_config"] = compilation_config
 
                     if "compilation_config" in kwargs:
                         if isinstance(kwargs["compilation_config"], str):
@@ -141,20 +148,28 @@ class ModelSingleton:
                     except ImportError:
                         raise ImportError("Please install vllm to use the vllm-async-engine backend.")
 
-                    """
+
                     # musa vllm v1 引擎特殊配置
-                    device = get_device()
-                    if device.startswith("musa"):
-                        import torch
-                        if torch.musa.is_available():
-                            compilation_config = CompilationConfig(
-                                cudagraph_capture_sizes=[1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 18, 20, 24, 28, 30],
-                                simple_cuda_graph=True
-                            )
-                            block_size = 32
-                            kwargs["compilation_config"] = compilation_config
-                            kwargs["block_size"] = block_size
-                    """
+                    # device = get_device()
+                    # if device.startswith("musa"):
+                    #     import torch
+                    #     if torch.musa.is_available():
+                    #         compilation_config = CompilationConfig(
+                    #             cudagraph_capture_sizes=[1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 18, 20, 24, 28, 30],
+                    #             simple_cuda_graph=True
+                    #         )
+                    #         block_size = 32
+                    #         kwargs["compilation_config"] = compilation_config
+                    #         kwargs["block_size"] = block_size
+
+                    # corex vllm v1 引擎特殊配置
+                    device_type = os.getenv("MINERU_LMDEPLOY_DEVICE", "")
+                    if device_type.lower() == "corex":
+                        compilation_config = CompilationConfig(
+                            cudagraph_mode="FULL_DECODE_ONLY",
+                            level=0
+                        )
+                        kwargs["compilation_config"] = compilation_config
 
                     if "compilation_config" in kwargs:
                         if isinstance(kwargs["compilation_config"], dict):

mineru/cli/fast_api.py

@@ -7,12 +7,12 @@ import asyncio
 import uvicorn
 import click
 import zipfile
+import shutil
 from pathlib import Path
 import glob
-from fastapi import Depends, FastAPI, HTTPException, UploadFile, File, Form
+from fastapi import Depends, FastAPI, HTTPException, UploadFile, File, Form, BackgroundTasks
 from fastapi.middleware.gzip import GZipMiddleware
 from fastapi.responses import JSONResponse, FileResponse
-from starlette.background import BackgroundTask
 from typing import List, Optional
 from loguru import logger
 
@@ -30,23 +30,30 @@ from mineru.version import __version__
 # 并发控制器
 _request_semaphore: Optional[asyncio.Semaphore] = None
 
+
 # 并发控制依赖函数
 async def limit_concurrency():
     if _request_semaphore is not None:
-        if _request_semaphore.locked():
+        # 检查信号量是否已用尽，如果是则拒绝请求
+        if _request_semaphore._value == 0:
             raise HTTPException(
                 status_code=503,
-                detail=f"Server is at maximum capacity: {os.getenv('MINERU_API_MAX_CONCURRENT_REQUESTS', 'unset')}. Please try again later."
+                detail=f"Server is at maximum capacity: {os.getenv('MINERU_API_MAX_CONCURRENT_REQUESTS', 'unset')}. Please try again later.",
             )
         async with _request_semaphore:
             yield
     else:
         yield
 
+
 def create_app():
     # By default, the OpenAPI documentation endpoints (openapi_url, docs_url, redoc_url) are enabled.
     # To disable the FastAPI docs and schema endpoints, set the environment variable MINERU_API_ENABLE_FASTAPI_DOCS=0.
-    enable_docs = str(os.getenv("MINERU_API_ENABLE_FASTAPI_DOCS", "1")).lower() in ("1", "true", "yes")
+    enable_docs = str(os.getenv("MINERU_API_ENABLE_FASTAPI_DOCS", "1")).lower() in (
+        "1",
+        "true",
+        "yes",
+    )
     app = FastAPI(
         openapi_url="/openapi.json" if enable_docs else None,
         docs_url="/docs" if enable_docs else None,
@@ -56,7 +63,9 @@ def create_app():
     # 初始化并发控制器：从环境变量MINERU_API_MAX_CONCURRENT_REQUESTS读取
     global _request_semaphore
     try:
-        max_concurrent_requests = int(os.getenv("MINERU_API_MAX_CONCURRENT_REQUESTS", "0"))
+        max_concurrent_requests = int(
+            os.getenv("MINERU_API_MAX_CONCURRENT_REQUESTS", "0")
+        )
     except ValueError:
         max_concurrent_requests = 0
 
@@ -67,6 +76,7 @@ def create_app():
     app.add_middleware(GZipMiddleware, minimum_size=1000)
     return app
 
+
 app = create_app()
 
 
@@ -76,27 +86,34 @@ def sanitize_filename(filename: str) -> str:
     移除路径遍历字符, 保留 Unicode 字母、数字、._-
     禁止隐藏文件
     """
-    sanitized = re.sub(r'[/\\\.]{2,}|[/\\]', '', filename)
-    sanitized = re.sub(r'[^\w.-]', '_', sanitized, flags=re.UNICODE)
-    if sanitized.startswith('.'):
-        sanitized = '_' + sanitized[1:]
-    return sanitized or 'unnamed'
+    sanitized = re.sub(r"[/\\.]{2,}|[/\\]", "", filename)
+    sanitized = re.sub(r"[^\w.-]", "_", sanitized, flags=re.UNICODE)
+    if sanitized.startswith("."):
+        sanitized = "_" + sanitized[1:]
+    return sanitized or "unnamed"
+
 
 def cleanup_file(file_path: str) -> None:
-    """清理临时 zip 文件"""
+    """清理临时文件或目录"""
     try:
         if os.path.exists(file_path):
-            os.remove(file_path)
+            if os.path.isfile(file_path):
+                os.remove(file_path)
+            elif os.path.isdir(file_path):
+                shutil.rmtree(file_path)
     except Exception as e:
         logger.warning(f"fail clean file {file_path}: {e}")
 
+
 def encode_image(image_path: str) -> str:
     """Encode image using base64"""
     with open(image_path, "rb") as f:
         return b64encode(f.read()).decode()
 
 
-def get_infer_result(file_suffix_identifier: str, pdf_name: str, parse_dir: str) -> Optional[str]:
+def get_infer_result(
+    file_suffix_identifier: str, pdf_name: str, parse_dir: str
+) -> Optional[str]:
     """从结果文件中读取推理结果"""
     result_file_path = os.path.join(parse_dir, f"{pdf_name}{file_suffix_identifier}")
     if os.path.exists(result_file_path):
@@ -107,11 +124,14 @@ def get_infer_result(file_suffix_identifier: str, pdf_name: str, parse_dir: str)
 
 @app.post(path="/file_parse", dependencies=[Depends(limit_concurrency)])
 async def parse_pdf(
-        files: List[UploadFile] = File(..., description="Upload pdf or image files for parsing"),
-        output_dir: str = Form("./output", description="Output local directory"),
-        lang_list: List[str] = Form(
-            ["ch"],
-            description="""(Adapted only for pipeline and hybrid backend)Input the languages in the pdf to improve OCR accuracy.Options:
+    background_tasks: BackgroundTasks,
+    files: List[UploadFile] = File(
+        ..., description="Upload pdf or image files for parsing"
+    ),
+    output_dir: str = Form("./output", description="Output local directory"),
+    lang_list: List[str] = Form(
+        ["ch"],
+        description="""(Adapted only for pipeline and hybrid backend)Input the languages in the pdf to improve OCR accuracy.Options:
 - ch: Chinese, English, Chinese Traditional.
 - ch_lite: Chinese, English, Chinese Traditional, Japanese.
 - ch_server: Chinese, English, Chinese Traditional, Japanese.
@@ -129,41 +149,54 @@ async def parse_pdf(
 - east_slavic: Russian, Belarusian, Ukrainian, English.
 - cyrillic: Russian, Belarusian, Ukrainian, Serbian (Cyrillic), Bulgarian, Mongolian, Abkhazian, Adyghe, Kabardian, Avar, Dargin, Ingush, Chechen, Lak, Lezgin, Tabasaran, Kazakh, Kyrgyz, Tajik, Macedonian, Tatar, Chuvash, Bashkir, Malian, Moldovan, Udmurt, Komi, Ossetian, Buryat, Kalmyk, Tuvan, Sakha, Karakalpak, English.
 - devanagari: Hindi, Marathi, Nepali, Bihari, Maithili, Angika, Bhojpuri, Magahi, Santali, Newari, Konkani, Sanskrit, Haryanvi, English.
-"""
-        ),
-        backend: str = Form(
-            "hybrid-auto-engine",
-            description="""The backend for parsing:
+""",
+    ),
+    backend: str = Form(
+        "hybrid-auto-engine",
+        description="""The backend for parsing:
 - pipeline: More general, supports multiple languages, hallucination-free.
 - vlm-auto-engine: High accuracy via local computing power, supports Chinese and English documents only.
 - vlm-http-client: High accuracy via remote computing power(client suitable for openai-compatible servers), supports Chinese and English documents only.
 - hybrid-auto-engine: Next-generation high accuracy solution via local computing power, supports multiple languages.
-- hybrid-http-client: High accuracy via remote computing power but requires a little local computing power(client suitable for openai-compatible servers), supports multiple languages."""
-        ),
-        parse_method: str = Form(
-            "auto",
-            description="""(Adapted only for pipeline and hybrid backend)The method for parsing PDF:
+- hybrid-http-client: High accuracy via remote computing power but requires a little local computing power(client suitable for openai-compatible servers), supports multiple languages.""",
+    ),
+    parse_method: str = Form(
+        "auto",
+        description="""(Adapted only for pipeline and hybrid backend)The method for parsing PDF:
 - auto: Automatically determine the method based on the file type
 - txt: Use text extraction method
 - ocr: Use OCR method for image-based PDFs
-"""
-        ),
-        formula_enable: bool = Form(True, description="Enable formula parsing."),
-        table_enable: bool = Form(True, description="Enable table parsing."),
-        server_url: Optional[str] = Form(
-            None,
-            description="(Adapted only for <vlm/hybrid>-http-client backend)openai compatible server url, e.g., http://127.0.0.1:30000"
-        ),
-        return_md: bool = Form(True, description="Return markdown content in response"),
-        return_middle_json: bool = Form(False, description="Return middle JSON in response"),
-        return_model_output: bool = Form(False, description="Return model output JSON in response"),
-        return_content_list: bool = Form(False, description="Return content list JSON in response"),
-        return_images: bool = Form(False, description="Return extracted images in response"),
-        response_format_zip: bool = Form(False, description="Return results as a ZIP file instead of JSON"),
-        start_page_id: int = Form(0, description="The starting page for PDF parsing, beginning from 0"),
-        end_page_id: int = Form(99999, description="The ending page for PDF parsing, beginning from 0"),
+""",
+    ),
+    formula_enable: bool = Form(True, description="Enable formula parsing."),
+    table_enable: bool = Form(True, description="Enable table parsing."),
+    server_url: Optional[str] = Form(
+        None,
+        description="(Adapted only for <vlm/hybrid>-http-client backend)openai compatible server url, e.g., http://127.0.0.1:30000",
+    ),
+    return_md: bool = Form(True, description="Return markdown content in response"),
+    return_middle_json: bool = Form(
+        False, description="Return middle JSON in response"
+    ),
+    return_model_output: bool = Form(
+        False, description="Return model output JSON in response"
+    ),
+    return_content_list: bool = Form(
+        False, description="Return content list JSON in response"
+    ),
+    return_images: bool = Form(
+        False, description="Return extracted images in response"
+    ),
+    response_format_zip: bool = Form(
+        False, description="Return results as a ZIP file instead of JSON"
+    ),
+    start_page_id: int = Form(
+        0, description="The starting page for PDF parsing, beginning from 0"
+    ),
+    end_page_id: int = Form(
+        99999, description="The ending page for PDF parsing, beginning from 0"
+    ),
 ):
-
     # 获取命令行配置参数
     config = getattr(app.state, "config", {})
 
@@ -171,6 +204,7 @@ async def parse_pdf(
         # 创建唯一的输出目录
         unique_dir = os.path.join(output_dir, str(uuid.uuid4()))
         os.makedirs(unique_dir, exist_ok=True)
+        background_tasks.add_task(cleanup_file, unique_dir)
 
         # 处理上传的PDF文件
         pdf_file_names = []
@@ -196,20 +230,21 @@ async def parse_pdf(
                 except Exception as e:
                     return JSONResponse(
                         status_code=400,
-                        content={"error": f"Failed to load file: {str(e)}"}
+                        content={"error": f"Failed to load file: {str(e)}"},
                     )
             else:
                 return JSONResponse(
                     status_code=400,
-                    content={"error": f"Unsupported file type: {file_suffix}"}
+                    content={"error": f"Unsupported file type: {file_suffix}"},
                 )
 
-
         # 设置语言列表，确保与文件数量一致
         actual_lang_list = lang_list
         if len(actual_lang_list) != len(pdf_file_names):
             # 如果语言列表长度不匹配，使用第一个语言或默认"ch"
-            actual_lang_list = [actual_lang_list[0] if actual_lang_list else "ch"] * len(pdf_file_names)
+            actual_lang_list = [
+                actual_lang_list[0] if actual_lang_list else "ch"
+            ] * len(pdf_file_names)
 
         # 调用异步处理函数
         await aio_do_parse(
@@ -231,13 +266,15 @@ async def parse_pdf(
             f_dump_content_list=return_content_list,
             start_page_id=start_page_id,
             end_page_id=end_page_id,
-            **config
+            **config,
         )
 
         # 根据 response_format_zip 决定返回类型
         if response_format_zip:
             zip_fd, zip_path = tempfile.mkstemp(suffix=".zip", prefix="mineru_results_")
             os.close(zip_fd)
+            background_tasks.add_task(cleanup_file, zip_path)
+
             with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
                 for pdf_name in pdf_file_names:
                     safe_pdf_name = sanitize_filename(pdf_name)
@@ -247,7 +284,13 @@ async def parse_pdf(
                     elif backend.startswith("vlm"):
                         parse_dir = os.path.join(unique_dir, pdf_name, "vlm")
                     elif backend.startswith("hybrid"):
-                        parse_dir = os.path.join(unique_dir, pdf_name, f"hybrid_{parse_method}")
+                        parse_dir = os.path.join(
+                            unique_dir, pdf_name, f"hybrid_{parse_method}"
+                        )
+                    else:
+                        # 未知 backend，跳过此文件
+                        logger.warning(f"Unknown backend type: {backend}, skipping {pdf_name}")
+                        continue
 
                     if not os.path.exists(parse_dir):
                         continue
@@ -256,35 +299,63 @@ async def parse_pdf(
                     if return_md:
                         path = os.path.join(parse_dir, f"{pdf_name}.md")
                         if os.path.exists(path):
-                            zf.write(path, arcname=os.path.join(safe_pdf_name, f"{safe_pdf_name}.md"))
+                            zf.write(
+                                path,
+                                arcname=os.path.join(
+                                    safe_pdf_name, f"{safe_pdf_name}.md"
+                                ),
+                            )
 
                     if return_middle_json:
                         path = os.path.join(parse_dir, f"{pdf_name}_middle.json")
                         if os.path.exists(path):
-                            zf.write(path, arcname=os.path.join(safe_pdf_name, f"{safe_pdf_name}_middle.json"))
+                            zf.write(
+                                path,
+                                arcname=os.path.join(
+                                    safe_pdf_name, f"{safe_pdf_name}_middle.json"
+                                ),
+                            )
 
                     if return_model_output:
                         path = os.path.join(parse_dir, f"{pdf_name}_model.json")
                         if os.path.exists(path):
-                            zf.write(path, arcname=os.path.join(safe_pdf_name, os.path.basename(path)))
+                            zf.write(
+                                path,
+                                arcname=os.path.join(
+                                    safe_pdf_name, f"{safe_pdf_name}_model.json"
+                                ),
+                            )
 
                     if return_content_list:
                         path = os.path.join(parse_dir, f"{pdf_name}_content_list.json")
                         if os.path.exists(path):
-                            zf.write(path, arcname=os.path.join(safe_pdf_name, f"{safe_pdf_name}_content_list.json"))
+                            zf.write(
+                                path,
+                                arcname=os.path.join(
+                                    safe_pdf_name, f"{safe_pdf_name}_content_list.json"
+                                ),
+                            )
 
                     # 写入图片
                     if return_images:
                         images_dir = os.path.join(parse_dir, "images")
-                        image_paths = glob.glob(os.path.join(glob.escape(images_dir), "*.jpg"))
+                        image_paths = glob.glob(
+                            os.path.join(glob.escape(images_dir), "*.jpg")
+                        )
                         for image_path in image_paths:
-                            zf.write(image_path, arcname=os.path.join(safe_pdf_name, "images", os.path.basename(image_path)))
+                            zf.write(
+                                image_path,
+                                arcname=os.path.join(
+                                    safe_pdf_name,
+                                    "images",
+                                    os.path.basename(image_path),
+                                ),
+                            )
 
             return FileResponse(
                 path=zip_path,
                 media_type="application/zip",
                 filename="results.zip",
-                background=BackgroundTask(cleanup_file, zip_path)
             )
         else:
             # 构建 JSON 结果
@@ -298,17 +369,31 @@ async def parse_pdf(
                 elif backend.startswith("vlm"):
                     parse_dir = os.path.join(unique_dir, pdf_name, "vlm")
                 elif backend.startswith("hybrid"):
-                    parse_dir = os.path.join(unique_dir, pdf_name, f"hybrid_{parse_method}")
+                    parse_dir = os.path.join(
+                        unique_dir, pdf_name, f"hybrid_{parse_method}"
+                    )
+                else:
+                    # 未知 backend，跳过此文件
+                    logger.warning(f"Unknown backend type: {backend}, skipping {pdf_name}")
+                    continue
 
                 if os.path.exists(parse_dir):
                     if return_md:
-                        data["md_content"] = get_infer_result(".md", pdf_name, parse_dir)
+                        data["md_content"] = get_infer_result(
+                            ".md", pdf_name, parse_dir
+                        )
                     if return_middle_json:
-                        data["middle_json"] = get_infer_result("_middle.json", pdf_name, parse_dir)
+                        data["middle_json"] = get_infer_result(
+                            "_middle.json", pdf_name, parse_dir
+                        )
                     if return_model_output:
-                        data["model_output"] = get_infer_result("_model.json", pdf_name, parse_dir)
+                        data["model_output"] = get_infer_result(
+                            "_model.json", pdf_name, parse_dir
+                        )
                     if return_content_list:
-                        data["content_list"] = get_infer_result("_content_list.json", pdf_name, parse_dir)
+                        data["content_list"] = get_infer_result(
+                            "_content_list.json", pdf_name, parse_dir
+                        )
                     if return_images:
                         images_dir = os.path.join(parse_dir, "images")
                         safe_pattern = os.path.join(glob.escape(images_dir), "*.jpg")
@@ -325,24 +410,24 @@ async def parse_pdf(
                 content={
                     "backend": backend,
                     "version": __version__,
-                    "results": result_dict
-                }
+                    "results": result_dict,
+                },
             )
     except Exception as e:
         logger.exception(e)
         return JSONResponse(
-            status_code=500,
-            content={"error": f"Failed to process file: {str(e)}"}
+            status_code=500, content={"error": f"Failed to process file: {str(e)}"}
         )
 
 
-@click.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True))
+@click.command(
+    context_settings=dict(ignore_unknown_options=True, allow_extra_args=True)
+)
 @click.pass_context
-@click.option('--host', default='127.0.0.1', help='Server host (default: 127.0.0.1)')
-@click.option('--port', default=8000, type=int, help='Server port (default: 8000)')
-@click.option('--reload', is_flag=True, help='Enable auto-reload (development mode)')
+@click.option("--host", default="127.0.0.1", help="Server host (default: 127.0.0.1)")
+@click.option("--port", default=8000, type=int, help="Server port (default: 8000)")
+@click.option("--reload", is_flag=True, help="Enable auto-reload (development mode)")
 def main(ctx, host, port, reload, **kwargs):
-
     kwargs.update(arg_parse(ctx))
 
     # 将配置参数存储到应用状态中
@@ -359,12 +444,7 @@ def main(ctx, host, port, reload, **kwargs):
     print(f"Start MinerU FastAPI Service: http://{host}:{port}")
     print(f"API documentation: http://{host}:{port}/docs")
 
-    uvicorn.run(
-        "mineru.cli.fast_api:app",
-        host=host,
-        port=port,
-        reload=reload
-    )
+    uvicorn.run("mineru.cli.fast_api:app", host=host, port=port, reload=reload)
 
 
 if __name__ == "__main__":

mineru/model/vlm/vllm_server.py

@@ -56,17 +56,22 @@ def main():
         model_path = auto_download_and_get_model_root_path("/", "vlm")
     if (not has_logits_processors_arg) and custom_logits_processors:
         args.extend(["--logits-processors", "mineru_vl_utils:MinerULogitsProcessor"])
-    """
+
     # musa vllm v1 引擎特殊配置 
-    device = get_device()
-    if device.startswith("musa"):
-        import torch
-        if torch.musa.is_available():
-            if not has_block_size_arg:
-                args.extend(["--block-size", "32"])
-            if not has_compilation_config:
-                args.extend(["--compilation-config", '{"cudagraph_capture_sizes": [1,2,3,4,5,6,7,8,10,12,14,16,18,20,24,28,30], "simple_cuda_graph": true}'])
-    """
+    # device = get_device()
+    # if device.startswith("musa"):
+    #     import torch
+    #     if torch.musa.is_available():
+    #         if not has_block_size_arg:
+    #             args.extend(["--block-size", "32"])
+    #         if not has_compilation_config:
+    #             args.extend(["--compilation-config", '{"cudagraph_capture_sizes": [1,2,3,4,5,6,7,8,10,12,14,16,18,20,24,28,30], "simple_cuda_graph": true}'])
+
+    # corex vllm v1 引擎特殊配置
+    device_type = os.getenv("MINERU_LMDEPLOY_DEVICE", "")
+    if device_type.lower() == "corex":
+        if not has_compilation_config:
+            args.extend(["--compilation-config", '{"cudagraph_mode": "FULL_DECODE_ONLY", "level": 0}'])
 
     # 重构参数，将模型路径作为位置参数
     sys.argv = [sys.argv[0]] + ["serve", model_path] + args

mineru/utils/block_sort.py

@@ -198,6 +198,10 @@ def model_init(model_name: str):
         if hasattr(torch, 'npu') and torch.npu.is_available():
             if torch.npu.is_bf16_supported():
                 bf_16_support = True
+    elif device_name.startswith("mlu"):
+        if hasattr(torch, 'mlu') and torch.mlu.is_available():
+            if torch.mlu.is_bf16_supported():
+                bf_16_support = True
 
     if model_name == 'layoutreader':
         # 检测modelscope的缓存目录是否存在

mineru/utils/config_reader.py

@@ -94,7 +94,11 @@ def get_device():
                         if torch.musa.is_available():
                             return "musa"
                     except Exception as e:
-                        pass
+                        try:
+                            if torch.mlu.is_available():
+                                return "mlu"
+                        except Exception as e:
+                            pass
         return "cpu"
 
 

mineru/utils/model_utils.py

@@ -429,6 +429,9 @@ def clean_memory(device='cuda'):
     elif str(device).startswith("musa"):
         if torch.musa.is_available():
             torch.musa.empty_cache()
+    elif str(device).startswith("mlu"):
+        if torch.mlu.is_available():
+            torch.mlu.empty_cache()
     gc.collect()
 
 
@@ -470,5 +473,8 @@ def get_vram(device) -> int:
     elif str(device).startswith("musa"):
         if torch.musa.is_available():
             total_memory = round(torch.musa.get_device_properties(device).total_memory / (1024 ** 3))  # 转为 GB
+    elif str(device).startswith("mlu"):
+        if torch.mlu.is_available():
+            total_memory = round(torch.mlu.get_device_properties(device).total_memory / (1024 ** 3))  # 转为 GB
 
     return total_memory

mineru/utils/os_env_config.py

@@ -11,6 +11,11 @@ def get_load_images_timeout() -> int:
     return get_value_from_string(env_value, 300)
 
 
+def get_load_images_threads() -> int:
+    env_value = os.getenv('MINERU_PDF_RENDER_THREADS', None)
+    return get_value_from_string(env_value, 4)
+
+
 def get_value_from_string(env_value: str, default_value: int) -> int:
     if env_value is not None:
         try:

mineru/utils/pdf_image_tools.py

@@ -1,5 +1,7 @@
 # Copyright (c) Opendatalab. All rights reserved.
 import os
+import signal
+import time
 from io import BytesIO
 
 import numpy as np
@@ -9,13 +11,13 @@ from PIL import Image, ImageOps
 
 from mineru.data.data_reader_writer import FileBasedDataWriter
 from mineru.utils.check_sys_env import is_windows_environment
-from mineru.utils.os_env_config import get_load_images_timeout
+from mineru.utils.os_env_config import get_load_images_timeout, get_load_images_threads
 from mineru.utils.pdf_reader import image_to_b64str, image_to_bytes, page_to_image
 from mineru.utils.enum_class import ImageType
 from mineru.utils.hash_utils import str_sha256
 from mineru.utils.pdf_page_id import get_end_page_id
 
-from concurrent.futures import ProcessPoolExecutor, TimeoutError as FuturesTimeoutError
+from concurrent.futures import ProcessPoolExecutor, wait, ALL_COMPLETED
 
 
 def pdf_page_to_image(page: pdfium.PdfPage, dpi=200, image_type=ImageType.PIL) -> dict:
@@ -57,7 +59,7 @@ def load_images_from_pdf(
     end_page_id=None,
     image_type=ImageType.PIL,
     timeout=None,
-    threads=4,
+    threads=None,
 ):
     """带超时控制的 PDF 转图片函数,支持多进程加速
 
@@ -67,8 +69,8 @@ def load_images_from_pdf(
         start_page_id (int, optional): 起始页码. Defaults to 0.
         end_page_id (int | None, optional): 结束页码. Defaults to None.
         image_type (ImageType, optional): 图片类型. Defaults to ImageType.PIL.
-        timeout (int | None, optional): 超时时间(秒)。如果为 None，则从环境变量 MINERU_PDF_LOAD_IMAGES_TIMEOUT 读取，若未设置则默认为 300 秒。
-        threads (int): 进程数,默认 4
+        timeout (int | None, optional): 超时时间(秒)。如果为 None，则从环境变量 MINERU_PDF_RENDER_TIMEOUT 读取，若未设置则默认为 300 秒。
+        threads (int): 进程数, 如果为 None，则从环境变量 MINERU_PDF_RENDER_THREADS 读取，若未设置则默认为 4.
 
     Raises:
         TimeoutError: 当转换超时时抛出
@@ -86,6 +88,9 @@ def load_images_from_pdf(
     else:
         if timeout is None:
             timeout = get_load_images_timeout()
+        if threads is None:
+            threads = get_load_images_threads()
+
         end_page_id = get_end_page_id(end_page_id, len(pdf_doc))
 
         # 计算总页数
@@ -108,11 +113,13 @@ def load_images_from_pdf(
 
             page_ranges.append((range_start, range_end))
 
-        # logger.debug(f"PDF to images using {actual_threads} processes, page ranges: {page_ranges}")
+        logger.debug(f"PDF to images using {actual_threads} processes, page ranges: {page_ranges}")
 
-        with ProcessPoolExecutor(max_workers=actual_threads) as executor:
+        executor = ProcessPoolExecutor(max_workers=actual_threads)
+        try:
             # 提交所有任务
             futures = []
+            future_to_range = {}
             for range_start, range_end in page_ranges:
                 future = executor.submit(
                     _load_images_from_pdf_worker,
@@ -122,27 +129,68 @@ def load_images_from_pdf(
                     range_end,
                     image_type,
                 )
-                futures.append((range_start, future))
-
-            try:
-                # 收集结果并按页码排序
-                all_results = []
-                for range_start, future in futures:
-                    images_list = future.result(timeout=timeout)
-                    all_results.append((range_start, images_list))
-
-                # 按起始页码排序并合并结果
-                all_results.sort(key=lambda x: x[0])
-                images_list = []
-                for _, imgs in all_results:
-                    images_list.extend(imgs)
-
-                return images_list, pdf_doc
-            except FuturesTimeoutError:
+                futures.append(future)
+                future_to_range[future] = range_start
+
+            # 使用 wait() 设置单一全局超时
+            done, not_done = wait(futures, timeout=timeout, return_when=ALL_COMPLETED)
+
+            # 检查是否有未完成的任务（超时情况）
+            if not_done:
+                # 超时：强制终止所有子进程
+                _terminate_executor_processes(executor)
                 pdf_doc.close()
-                executor.shutdown(wait=False, cancel_futures=True)
                 raise TimeoutError(f"PDF to images conversion timeout after {timeout}s")
 
+            # 所有任务完成，收集结果
+            all_results = []
+            for future in futures:
+                range_start = future_to_range[future]
+                # 这里不需要 timeout，因为任务已完成
+                images_list = future.result()
+                all_results.append((range_start, images_list))
+
+            # 按起始页码排序并合并结果
+            all_results.sort(key=lambda x: x[0])
+            images_list = []
+            for _, imgs in all_results:
+                images_list.extend(imgs)
+
+            return images_list, pdf_doc
+
+        except Exception as e:
+            # 发生任何异常时，确保清理子进程
+            _terminate_executor_processes(executor)
+            pdf_doc.close()
+            if isinstance(e, TimeoutError):
+                raise
+            raise
+        finally:
+            executor.shutdown(wait=False, cancel_futures=True)
+
+
+def _terminate_executor_processes(executor):
+    """强制终止 ProcessPoolExecutor 中的所有子进程"""
+    if hasattr(executor, '_processes'):
+        for pid, process in executor._processes.items():
+            if process.is_alive():
+                try:
+                    # 先发送 SIGTERM 允许优雅退出
+                    os.kill(pid, signal.SIGTERM)
+                except (ProcessLookupError, OSError):
+                    pass
+
+        # 给子进程一点时间响应 SIGTERM
+        time.sleep(0.1)
+
+        # 对仍然存活的进程发送 SIGKILL 强制终止
+        for pid, process in executor._processes.items():
+            if process.is_alive():
+                try:
+                    os.kill(pid, signal.SIGKILL)
+                except (ProcessLookupError, OSError):
+                    pass
+
 
 def load_images_from_pdf_core(
     pdf_bytes: bytes,

mineru/version.py

@@ -1 +1 @@
-__version__ = "2.7.3"
+__version__ = "2.7.5"

{mineru-2.7.3.dist-info → mineru-2.7.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mineru
-Version: 2.7.3
+Version: 2.7.5
 Summary: A practical tool for converting PDF to Markdown
 License: AGPL-3.0
 Project-URL: homepage, https://mineru.net/
@@ -135,16 +135,21 @@ Dynamic: license-file
 
 # Changelog
 
-- 2026/01/23 2.7.2 Release
-  - Added support for domestic computing platforms Hygon, Enflame, and Moore Threads. Currently, the officially supported domestic computing platforms include:
+- 2026/01/30 2.7.4 Release
+  - Added support for domestic computing platforms IluvatarCorex and Cambricon. Currently, the officially supported domestic computing platforms include:
     - [Ascend](https://opendatalab.github.io/MinerU/zh/usage/acceleration_cards/Ascend/) 
     - [T-Head](https://opendatalab.github.io/MinerU/zh/usage/acceleration_cards/THead/) 
     - [METAX](https://opendatalab.github.io/MinerU/zh/usage/acceleration_cards/METAX/) 
     - [Hygon](https://opendatalab.github.io/MinerU/zh/usage/acceleration_cards/Hygon/)
     - [Enflame](https://opendatalab.github.io/MinerU/zh/usage/acceleration_cards/Enflame/)
     - [MooreThreads](https://opendatalab.github.io/MinerU/zh/usage/acceleration_cards/MooreThreads/)
+    - [IluvatarCorex](https://opendatalab.github.io/MinerU/zh/usage/acceleration_cards/IluvatarCorex/)
+    - [Cambricon](https://opendatalab.github.io/MinerU/zh/usage/acceleration_cards/Cambricon/)
   - MinerU continues to ensure compatibility with domestic hardware platforms, supporting mainstream chip architectures. With secure and reliable technology, we empower researchers, government, and enterprises to reach new heights in document digitization!
-  - Cross-page table merging optimization, improving merge success rate and merge quality
+
+- 2026/01/23 2.7.2 Release
+  - Added support for domestic computing platforms Hygon, Enflame, and Moore Threads.
+  - Cross-page table merging optimization, improving merge success rate and merge quality.
 
 - 2026/01/06 2.7.1 Release
   - fix bug: #4300

{mineru-2.7.3.dist-info → mineru-2.7.5.dist-info}/RECORD

@@ -1,5 +1,5 @@
 mineru/__init__.py,sha256=8CRrCQVuExa0BttRFh3Z40lFy2K5jN0sp67KWjOlj5c,50
-mineru/version.py,sha256=uf6cgtzZWaYn5QApMyykHXMzWM_oEqWLhYTsWSWu2_k,22
+mineru/version.py,sha256=lBcjVwt4I0-VUeE_7gM1gQBbtKOi9jGT3DavJbzcYnQ,22
 mineru/backend/__init__.py,sha256=8CRrCQVuExa0BttRFh3Z40lFy2K5jN0sp67KWjOlj5c,50
 mineru/backend/utils.py,sha256=GLJU3IznDmhE1_qNmkU1UOtsuskIHBezgsEVO6Uar-Y,698
 mineru/backend/hybrid/__init__.py,sha256=IFgr2C8NfSAj8q7JF7QOqMvCiJ6Fc8TIuU3Uh2DaFZU,51
@@ -8,23 +8,23 @@ mineru/backend/hybrid/hybrid_magic_model.py,sha256=_DvBq5WP_UZvmHfhZloxqv-MKoWWe
 mineru/backend/hybrid/hybrid_model_output_to_middle_json.py,sha256=yE-c1eGa5LzPqLfKfvBON_SJRljqyz2B7LiglFcE7FQ,8468
 mineru/backend/pipeline/__init__.py,sha256=8CRrCQVuExa0BttRFh3Z40lFy2K5jN0sp67KWjOlj5c,50
 mineru/backend/pipeline/batch_analyze.py,sha256=3UBs2WOwcI-mfGAlxZt437OqSOleXPLnpYbrD9h5D54,21303
-mineru/backend/pipeline/model_init.py,sha256=wz8VdieUXCxzS9NQqkmaiXweey8xz-_DBvmC1OuK_B4,12469
+mineru/backend/pipeline/model_init.py,sha256=2DHYwqrWXtK3v6u5EfoFHZqfUNE00MLfzuEGh-OhoBg,12609
 mineru/backend/pipeline/model_json_to_middle_json.py,sha256=reXkUR_wKmJD64d7vRNXMxFviwkzDlGjRshpdwsVquI,10951
 mineru/backend/pipeline/model_list.py,sha256=7cXMBfZrP0K6qWueg1D_-WoUANeSINzkn_ic9E7YQLs,222
 mineru/backend/pipeline/para_split.py,sha256=Kq95MmvkPm7rKxlCSGiTvVKyF7CErHI2eGGAs5sLl0Q,17119
-mineru/backend/pipeline/pipeline_analyze.py,sha256=RPQTtu-m4WYVQxIRKLj39VPyaKqroi5Tc9-FCEuQhX8,6599
+mineru/backend/pipeline/pipeline_analyze.py,sha256=82XH7hVynuD_nuk-v7a_zhx_3Z_MHS31sIurQ0lHmXQ,6737
 mineru/backend/pipeline/pipeline_magic_model.py,sha256=w8jGx8f6yZN0Wf2yPP3L9rYKc9rogxreZCrUJzJvPO8,14974
 mineru/backend/pipeline/pipeline_middle_json_mkcontent.py,sha256=NJCLGKE7BqM24bRdpXCfTalyiqozowFZjpdzpIUy5aA,14672
 mineru/backend/vlm/__init__.py,sha256=8CRrCQVuExa0BttRFh3Z40lFy2K5jN0sp67KWjOlj5c,50
 mineru/backend/vlm/model_output_to_middle_json.py,sha256=AqYX44gS9crUO_t7SuUatD71EVjow6pI6yA2Ik3gQ0s,5139
-mineru/backend/vlm/utils.py,sha256=1qma_KmDjRfOckcPbriGgRhS1XMk_johsyACfwcmDr4,3844
-mineru/backend/vlm/vlm_analyze.py,sha256=ttnQBUy1PEm9JZoF2G1_z-7gA3MgUUUBhz6OypCb4_g,14765
+mineru/backend/vlm/utils.py,sha256=PIYqOStLCZlxU9TiZK4EhP90rPYIe_0thEZeP01YPls,3940
+mineru/backend/vlm/vlm_analyze.py,sha256=_2-xJC2C2rT87lZw8JZfC6PFFY0FfEbM9PK2TOkIJao,15604
 mineru/backend/vlm/vlm_magic_model.py,sha256=RodoVwNJhzjyuRLn5Io5gFMIX1NxCuuLzCbUxGaKV80,21447
 mineru/backend/vlm/vlm_middle_json_mkcontent.py,sha256=w-Szbm4HitR7MY4pinSCZZdXtPSqmtlU9cjNh4IOQyg,29499
 mineru/cli/__init__.py,sha256=8CRrCQVuExa0BttRFh3Z40lFy2K5jN0sp67KWjOlj5c,50
 mineru/cli/client.py,sha256=mPNfMEShVG-ithmlJQ5nGRIad2gCZgUjBGHN7zAmLhQ,6978
 mineru/cli/common.py,sha256=fMPc235DtnupQkh9uFIMHUpxOSvCp5yc3A56sAabAWY,20475
-mineru/cli/fast_api.py,sha256=TGpZqyUE1kg2eXsP76pr0p1yqNOOU9jyjL5Pc0FJwRc,16637
+mineru/cli/fast_api.py,sha256=Zgbp8giikcuOngZalmzrsfUMrdKnOd9TAAZrMfGQWXs,18664
 mineru/cli/gradio_app.py,sha256=2IIWOm2bEHHq5BZMlfmN3yAJw1Nf8SUALTQ95o-bYy0,21863
 mineru/cli/models_download.py,sha256=LNfoIpUlJM7m7qb2SiCxtjMDw4jILBQtZwNP2JoY81U,4815
 mineru/cli/vlm_server.py,sha256=27HaqO3wpMXSA_nA3CC6JOBTHK3q66SP00cD6m9HuQE,1974
@@ -151,17 +151,17 @@ mineru/model/utils/tools/infer/predict_system.py,sha256=hkegkn6hq2v2zqHVAP615-k-
 mineru/model/utils/tools/infer/pytorchocr_utility.py,sha256=i1PFN-_kefJUUZ4Vk7igs1TU8gfErTDlDXY6-8Uaurw,9323
 mineru/model/vlm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mineru/model/vlm/lmdeploy_server.py,sha256=PvxJNcUIKB8VzWMDXeV1t0SHSgz_ULO36ZAzJbppz90,3262
-mineru/model/vlm/vllm_server.py,sha256=DtYRAHINYN4qkR2onVMofvANPTkSP6tE4IRY_vZgpiA,3079
+mineru/model/vlm/vllm_server.py,sha256=7taySlBANFBTS81Q8PJ6gJWjTgjnFQoGvMknK4NuyLY,3360
 mineru/resources/header.html,sha256=7xrf6bGloR-3ZeTDyA-JvavE_NeRuUDe3p07cEKUXSI,4769
 mineru/resources/fasttext-langdetect/lid.176.ftz,sha256=jzRyz-hzintgmejpmcPL-uDc0VaWqsfXc4qAOdtgPoM,938013
 mineru/utils/__init__.py,sha256=8CRrCQVuExa0BttRFh3Z40lFy2K5jN0sp67KWjOlj5c,50
 mineru/utils/block_pre_proc.py,sha256=uGBmxf2MR9bplTnQI8xHjCI-kj3plRhJr0hcWKidbOQ,9632
-mineru/utils/block_sort.py,sha256=MmgjZBcmaWssAglzE75VixjtJ_BLNUHO0gvCNQHvlY4,13538
+mineru/utils/block_sort.py,sha256=e6nNjdUeRixT70OfvlEzM1FGwKxFSVwiLtwYGrsG_U0,13724
 mineru/utils/boxbase.py,sha256=xnGA1k7hVtTQrreqlJmK-SA3y9edTHgLmGiqGrSXckE,7568
 mineru/utils/char_utils.py,sha256=74T5Ylr5mi1uddAIuJku9Z6sH7vhR7t595_H7qmbu4c,1777
 mineru/utils/check_sys_env.py,sha256=TRjzg4xWyoSGrgv4KaP225A-99xBgLAfZ1cPcGqrBAA,1191
 mineru/utils/cli_parser.py,sha256=4seFAu1kulsYnw6WM2q_cxgEOt2tErZVkI-LNEF_kGw,1445
-mineru/utils/config_reader.py,sha256=mfulokOzI-33sZy7S-wEVbY3z01PdC7X3761fuhqR3s,4393
+mineru/utils/config_reader.py,sha256=mwXYVuj52mA__2BU2qOPP0Pn9m0dDLi4mAqPS9a4Pjo,4575
 mineru/utils/cut_image.py,sha256=g3m4nfcJNWlxi-P0kpXTtlmspXkMcLCfGwmYuQ-Z2hE,751
 mineru/utils/draw_bbox.py,sha256=FkgppjUzRhN-uxvChdkhHXcDavJEaApMD6qC6qoRwfQ,20292
 mineru/utils/engine_utils.py,sha256=Jmao9-O-sZDzH7vANKEDaY6NJ8tuthKsTr23LFIeBLU,2203
@@ -172,12 +172,12 @@ mineru/utils/hash_utils.py,sha256=UPS_8NRBmVumdyOv16Lmv6Ly2xK8OVDJEe5gG6gKIFk,85
 mineru/utils/language.py,sha256=7RT3mxSa7jdpoC5ySd7ZddHA7TO7UsnmDOWiYZAxuyg,1433
 mineru/utils/llm_aided.py,sha256=9WUytvxenSAuaWR4sTQhVPQ5h8pY0wVOH1O2sj_6dLs,5149
 mineru/utils/magic_model_utils.py,sha256=8Hv-BDk9Ez4TUx6hrVJ_675yZZggPj6Uib81lSpm0ig,11683
-mineru/utils/model_utils.py,sha256=w-jSN7Ilh27FlMjPpKNO6MPbo_dT5Ln7zCQcXaREl_k,19605
+mineru/utils/model_utils.py,sha256=xlw5hUYKa6o1NiM8PoXO1HFvHfrgY5e4Ut_upGEY9yI,19909
 mineru/utils/models_download_utils.py,sha256=UfjvwhxO6BkJHa5JSpEVNZ71GoLMPMmJpym3THET2T4,2957
 mineru/utils/ocr_utils.py,sha256=lPIrwNUib5mrzUkponRYHuUCdjV2qvETNLSzOLyflrU,15990
-mineru/utils/os_env_config.py,sha256=ZNtkR4KrJW72CeIoTNzGDL6tMKv_hL8nzvWIssGWbqY,842
+mineru/utils/os_env_config.py,sha256=VHK9lS3QFJhrwWa9FOFU1Swm7oXnby4SaNNjTyonTTg,990
 mineru/utils/pdf_classify.py,sha256=6DF5pH_9Uq83fsFtp7n4i-OdYQGzoNOV9L0VBUhgBMQ,8078
-mineru/utils/pdf_image_tools.py,sha256=L2kHKoFaQo4CGjS1d68JACrlBycx6gyCnnFlbBFRKuw,8273
+mineru/utils/pdf_image_tools.py,sha256=tTSk39fgJKLEshwPAuJGLl_pVSrmEKjWA55F6dGcr4g,9987
 mineru/utils/pdf_page_id.py,sha256=em966k12CRW4Rj49RGiLB_8ILwkXPBnWRetApax3eTs,400
 mineru/utils/pdf_reader.py,sha256=WeINm5SyWBUXT0wP9lzIbeHs8P6WUIkN6nVL5X4LzG4,3267
 mineru/utils/pdf_text_tool.py,sha256=KEztjfdqsIHHuiTEAMAL7Lr1OS3R7Ur-uTqGiCRjReQ,1364
@@ -185,9 +185,9 @@ mineru/utils/run_async.py,sha256=rPeP4BCZerR8VByRDhiYzfZiahLVqoZEBVAS54dAjNg,128
 mineru/utils/span_block_fix.py,sha256=0eVQjJCrT03woRt9hoh6Uu42Tp1dacfGTv2x3B9qq94,8797
 mineru/utils/span_pre_proc.py,sha256=nu6Bh5TWPKFzHuFfbEs0Asr04M4xOL5IONz_8GJHn44,13862
 mineru/utils/table_merge.py,sha256=LORxz0THemCqH746FMViqEuLzM088M4HgIkEuwDIfNU,21393
-mineru-2.7.3.dist-info/licenses/LICENSE.md,sha256=jVa0BUaKrRH4erV2P5AeJ24I2WRv9chIGxditreJ6e0,34524
-mineru-2.7.3.dist-info/METADATA,sha256=XDUBoY78vVkmR2TFpXk_frncPD6D_Ev067KuoRUJR2U,36621
-mineru-2.7.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mineru-2.7.3.dist-info/entry_points.txt,sha256=JbtrCPhx1T32s7TONUsteKg-24ZwRT1HSiFtW5jypVw,376
-mineru-2.7.3.dist-info/top_level.txt,sha256=zuGQfZcbsHv4I4oKI9gaKPqEWBFm6xJroKuug2LnKP8,7
-mineru-2.7.3.dist-info/RECORD,,
+mineru-2.7.5.dist-info/licenses/LICENSE.md,sha256=jVa0BUaKrRH4erV2P5AeJ24I2WRv9chIGxditreJ6e0,34524
+mineru-2.7.5.dist-info/METADATA,sha256=MvPv4AgyLwaHz3hspAPrZ0wEeSE0wnu0MkMwfAJ5hTs,36928
+mineru-2.7.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mineru-2.7.5.dist-info/entry_points.txt,sha256=a9AHBIiYe3dpT3oofVQJC8fI0WjDhQASCUlhdMOK120,376
+mineru-2.7.5.dist-info/top_level.txt,sha256=zuGQfZcbsHv4I4oKI9gaKPqEWBFm6xJroKuug2LnKP8,7
+mineru-2.7.5.dist-info/RECORD,,

{mineru-2.7.3.dist-info → mineru-2.7.5.dist-info}/entry_points.txt

@@ -1,5 +1,5 @@
 [console_scripts]
-mineru = mineru.cli:client.main
+mineru = mineru.cli.client:main
 mineru-api = mineru.cli.fast_api:main
 mineru-gradio = mineru.cli.gradio_app:main
 mineru-lmdeploy-server = mineru.cli.vlm_server:lmdeploy_server