markitdown-glmocr 0.1.0__tar.gz → 0.2.2__tar.gz

{markitdown_glmocr-0.1.0 → markitdown_glmocr-0.2.2}/.gitignore

@@ -171,3 +171,4 @@ src/.DS_Store
 .secrets.local
 *.secrets
 .env.local
+test-data/

{markitdown_glmocr-0.1.0 → markitdown_glmocr-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markitdown-glmocr
-Version: 0.1.0
+Version: 0.2.2
 Summary: Intelligent PDF to Markdown converter using glmocr SDK
 Project-URL: Documentation, https://github.com/microsoft/markitdown#readme
 Project-URL: Issues, https://github.com/microsoft/markitdown/issues
@@ -218,6 +218,93 @@ glmocr SDK 返回的结构化数据支持以下标签：
 - `Pillow>=9.0.0` - 图像处理
 - `glmocr` - 智谱 OCR SDK（可选，AI 功能需要）
 
+## 发布到 PyPI
+
+### 前置条件
+
+1. 安装构建工具：
+
+```bash
+pip install build twine hatch
+```
+
+2. 配置 PyPI API Token（Windows 用户环境变量）：
+
+```powershell
+# PowerShell 设置用户环境变量
+[System.Environment]::SetEnvironmentVariable('PYPI_API_TOKEN', 'pypi-...', 'User')
+```
+
+或在 Bash/Zsh 中：
+
+```bash
+export PYPI_API_TOKEN="pypi-..."
+```
+
+### 快速发布（推荐）
+
+项目根目录提供了上传脚本，可一键发布两个插件：
+
+**Bash / Git Bash:**
+```bash
+# 构建两个插件
+cd packages/markitdown-glmocr && hatch build
+
+cd ../markitdown-paddleocr && hatch build
+
+# 上传（自动上传所有构建的版本）
+cd ../..
+./scripts/pypi-upload.sh
+
+# 或指定版本号
+./scripts/pypi-upload.sh 0.2.0
+```
+
+**PowerShell:**
+```powershell
+# 构建两个插件
+cd packages/markitdown-glmocr; hatch build
+cd ../markitdown-paddleocr; hatch build
+
+# 上传
+cd ../..
+.\scripts\pypi-upload.ps1
+
+# 或指定版本号
+.\scripts\pypi-upload.ps1 -Version "0.2.0"
+```
+
+### 手动发布
+
+```bash
+# 1. 进入项目目录
+cd packages/markitdown-glmocr
+
+# 2. 构建
+hatch build
+
+# 3. 检查
+twine check dist/*
+
+# 4. 上传
+twine upload --username __token__ --password "$PYPI_API_TOKEN" --disable-progress-bar dist/*
+```
+
+### 发布到 TestPyPI（测试）
+
+```bash
+twine upload --repository testpypi --username __token__ --password "$PYPI_API_TOKEN" --disable-progress-bar dist/*
+
+# 从 TestPyPI 安装验证
+pip install --index-url https://test.pypi.org/simple/ markitdown-glmocr
+```
+
+### 注意事项
+
+- 发布前确保 `src/markitdown_glmocr/__about__.py` 中的版本号已更新
+- 同一版本号不能重复上传，如需修正必须 bump 版本号
+- `PYPI_API_TOKEN` 切勿提交到代码仓库
+
 ## 许可证
 
 MIT

{markitdown_glmocr-0.1.0 → markitdown_glmocr-0.2.2}/README.md

@@ -191,6 +191,93 @@ glmocr SDK 返回的结构化数据支持以下标签：
 - `Pillow>=9.0.0` - 图像处理
 - `glmocr` - 智谱 OCR SDK（可选，AI 功能需要）
 
+## 发布到 PyPI
+
+### 前置条件
+
+1. 安装构建工具：
+
+```bash
+pip install build twine hatch
+```
+
+2. 配置 PyPI API Token（Windows 用户环境变量）：
+
+```powershell
+# PowerShell 设置用户环境变量
+[System.Environment]::SetEnvironmentVariable('PYPI_API_TOKEN', 'pypi-...', 'User')
+```
+
+或在 Bash/Zsh 中：
+
+```bash
+export PYPI_API_TOKEN="pypi-..."
+```
+
+### 快速发布（推荐）
+
+项目根目录提供了上传脚本，可一键发布两个插件：
+
+**Bash / Git Bash:**
+```bash
+# 构建两个插件
+cd packages/markitdown-glmocr && hatch build
+
+cd ../markitdown-paddleocr && hatch build
+
+# 上传（自动上传所有构建的版本）
+cd ../..
+./scripts/pypi-upload.sh
+
+# 或指定版本号
+./scripts/pypi-upload.sh 0.2.0
+```
+
+**PowerShell:**
+```powershell
+# 构建两个插件
+cd packages/markitdown-glmocr; hatch build
+cd ../markitdown-paddleocr; hatch build
+
+# 上传
+cd ../..
+.\scripts\pypi-upload.ps1
+
+# 或指定版本号
+.\scripts\pypi-upload.ps1 -Version "0.2.0"
+```
+
+### 手动发布
+
+```bash
+# 1. 进入项目目录
+cd packages/markitdown-glmocr
+
+# 2. 构建
+hatch build
+
+# 3. 检查
+twine check dist/*
+
+# 4. 上传
+twine upload --username __token__ --password "$PYPI_API_TOKEN" --disable-progress-bar dist/*
+```
+
+### 发布到 TestPyPI（测试）
+
+```bash
+twine upload --repository testpypi --username __token__ --password "$PYPI_API_TOKEN" --disable-progress-bar dist/*
+
+# 从 TestPyPI 安装验证
+pip install --index-url https://test.pypi.org/simple/ markitdown-glmocr
+```
+
+### 注意事项
+
+- 发布前确保 `src/markitdown_glmocr/__about__.py` 中的版本号已更新
+- 同一版本号不能重复上传，如需修正必须 bump 版本号
+- `PYPI_API_TOKEN` 切勿提交到代码仓库
+
 ## 许可证
 
 MIT

markitdown_glmocr-0.2.2/src/markitdown_glmocr/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.2.2"

markitdown_glmocr-0.2.2/src/markitdown_glmocr/_config.py

@@ -0,0 +1,43 @@
+"""Configuration for markitdown-glmocr."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class ScanDetectionMode(str, Enum):
+    """扫描检测模式。
+
+    - PAGE_BY_PAGE: 逐页分析，当前默认行为
+    - FIRST_PAGE_HINT: 首页是扫描件则全文档使用OCR
+    - SAMPLING: 抽样前N页，多数是扫描件则全部OCR
+    """
+    PAGE_BY_PAGE = "page_by_page"
+    FIRST_PAGE_HINT = "first_page_hint"
+    SAMPLING = "sampling"
+
+
+@dataclass
+class GlmOcrConfig:
+    """markitdown-glmocr configuration.
+    
+    Configuration priority (high to low):
+    1. Constructor kwargs
+    2. Environment variables
+    3. .env file
+    4. Built-in defaults
+    """
+    
+    # API configuration
+    api_key: str = ""  # Reads from ZHIPU_API_KEY by default
+    
+    # OCR configuration
+    timeout: int = 1800
+    enable_layout: bool = False
+    
+    # Processing strategy
+    force_ai: bool = False
+    
+    # Scan detection mode for optimization
+    scan_detection_mode: ScanDetectionMode = ScanDetectionMode.SAMPLING
+    scan_sample_pages: int = 3  # Number of pages to sample in SAMPLING mode
+    scan_text_threshold: int = 50  # Min text length to consider page as non-scanned

markitdown_glmocr-0.2.2/src/markitdown_glmocr/_converter.py

@@ -0,0 +1,551 @@
+"""GlmOcr PDF/Image Converter - Intelligent PDF and Image to Markdown conversion."""
+
+import io
+import logging
+import sys
+from typing import Any, BinaryIO, Optional
+
+from markitdown import DocumentConverter, DocumentConverterResult, StreamInfo
+from markitdown._exceptions import (
+    MISSING_DEPENDENCY_MESSAGE,
+    MissingDependencyException,
+)
+
+from ._config import GlmOcrConfig, ScanDetectionMode
+
+# Import dependencies
+_dependency_exc_info = None
+try:
+    import pdfminer
+    import pdfminer.high_level
+    import pdfplumber
+except ImportError:
+    _dependency_exc_info = sys.exc_info()
+
+# glmocr SDK
+try:
+    import glmocr
+    from glmocr import GlmOcr
+except ImportError:
+    glmocr = None
+    GlmOcr = None
+
+
+ACCEPTED_MIME_TYPE_PREFIXES = [
+    "application/pdf",
+    "application/x-pdf",
+    "image/jpeg",
+    "image/png",
+]
+
+ACCEPTED_FILE_EXTENSIONS = [".pdf", ".jpg", ".jpeg", ".png"]
+
+
+logger = logging.getLogger(__name__)
+
+
+class GlmOcrConverter(DocumentConverter):
+    """
+    Intelligent PDF/Image converter using glmocr SDK.
+
+    Features:
+    - Auto-detect page content type (plain text vs images/tables)
+    - Plain text pages use pdfplumber/pdfminer (fast, free)
+    - Complex pages use glmocr SDK for AI-powered OCR
+    - Image files (PNG, JPG) use glmocr SDK directly
+    - One-liner: glmocr.parse("document.pdf") handles everything
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        timeout: int = 1800,
+        enable_layout: bool = False,
+        force_ai: bool = False,
+        scan_detection_mode: Optional[ScanDetectionMode] = None,
+        scan_sample_pages: Optional[int] = None,
+        scan_text_threshold: Optional[int] = None,
+        config: Optional[GlmOcrConfig] = None,
+    ):
+        """
+        Initialize converter.
+
+        Args:
+            api_key: Zhipu API key (reads from ZHIPU_API_KEY env var if not provided)
+            timeout: Request timeout in seconds (default: 1800)
+            enable_layout: Enable layout detection (default: False)
+            force_ai: Force all pages to use AI (default: False)
+            scan_detection_mode: 扫描检测模式，优化扫描PDF处理
+            scan_sample_pages: SAMPLING模式下抽样页数 (default: 3)
+            scan_text_threshold: 判定为扫描件的最小文本长度阈值 (default: 50)
+            config: Optional GlmOcrConfig instance
+        """
+        if glmocr is None:
+            raise ImportError(
+                "glmocr is required. Install with: pip install markitdown-glmocr[glmocr]"
+            )
+
+        # Use config if provided
+        if config:
+            self.api_key = api_key or config.api_key
+            self.timeout = timeout if timeout != 1800 else config.timeout
+            self.enable_layout = (
+                enable_layout if enable_layout else config.enable_layout
+            )
+            self.force_ai = force_ai or config.force_ai
+            self.scan_detection_mode = (
+                scan_detection_mode
+                if scan_detection_mode is not None
+                else config.scan_detection_mode
+            )
+            self.scan_sample_pages = (
+                scan_sample_pages
+                if scan_sample_pages is not None
+                else config.scan_sample_pages
+            )
+            self.scan_text_threshold = (
+                scan_text_threshold
+                if scan_text_threshold is not None
+                else config.scan_text_threshold
+            )
+        else:
+            self.api_key = api_key
+            self.timeout = timeout
+            self.enable_layout = enable_layout
+            self.force_ai = force_ai
+            self.scan_detection_mode = (
+                scan_detection_mode
+                if scan_detection_mode is not None
+                else ScanDetectionMode.SAMPLING
+            )
+            self.scan_sample_pages = (
+                scan_sample_pages if scan_sample_pages is not None else 3
+            )
+            self.scan_text_threshold = (
+                scan_text_threshold if scan_text_threshold is not None else 50
+            )
+
+        # Lazy init GlmOcr instance
+        self._glmocr: Optional[GlmOcr] = None
+
+    def _get_glmocr(self) -> GlmOcr:
+        """Get or create GlmOcr instance."""
+        if self._glmocr is None:
+            kwargs = {"timeout": self.timeout, "enable_layout": self.enable_layout}
+            if self.api_key:
+                kwargs["api_key"] = self.api_key
+            self._glmocr = GlmOcr(**kwargs)
+        return self._glmocr
+
+    def accepts(
+        self,
+        file_stream: BinaryIO,
+        stream_info: StreamInfo,
+        **kwargs: Any,
+    ) -> bool:
+        mimetype = (stream_info.mimetype or "").lower()
+        extension = (stream_info.extension or "").lower()
+
+        if extension in ACCEPTED_FILE_EXTENSIONS:
+            return True
+
+        for prefix in ACCEPTED_MIME_TYPE_PREFIXES:
+            if mimetype.startswith(prefix):
+                return True
+
+        return False
+
+    def convert(
+        self,
+        file_stream: BinaryIO,
+        stream_info: StreamInfo,
+        **kwargs: Any,
+    ) -> DocumentConverterResult:
+        if _dependency_exc_info is not None:
+            raise MissingDependencyException(
+                MISSING_DEPENDENCY_MESSAGE.format(
+                    converter=type(self).__name__,
+                    extension=".pdf",
+                    feature="pdf",
+                )
+            ) from _dependency_exc_info[1].with_traceback(_dependency_exc_info[2])
+
+        extension = (stream_info.extension or "").lower()
+
+        logger.info("GlmOcrConverter: 开始转换, 文件类型=%s", extension)
+
+        # Image files: use glmocr directly
+        if extension in (".jpg", ".jpeg", ".png"):
+            return self._convert_image(file_stream, extension)
+
+        # PDF files: use hybrid approach
+        return self._convert_pdf(file_stream)
+
+    def _convert_image(
+        self, file_stream: BinaryIO, extension: str = ".png"
+    ) -> DocumentConverterResult:
+        """Convert image file using glmocr SDK."""
+        img_bytes = file_stream.read()
+
+        logger.info("GlmOcrConverter: 开始 OCR 识别图片, 格式=%s", extension)
+        try:
+            result = self._get_glmocr().parse(img_bytes)
+        except Exception as e:
+            logger.error(
+                "GlmOcrConverter: 图片 OCR 识别异常, 格式=%s, 错误=%s", extension, e
+            )
+            raise
+
+        # Check for errors
+        d = result.to_dict()
+        if "error" in d:
+            logger.error(
+                "GlmOcrConverter: 图片 OCR 返回错误, 格式=%s, 错误=%s",
+                extension,
+                d["error"],
+            )
+            raise RuntimeError(
+                f"GlmOcrConverter: glmocr SDK returned error: {d['error']}"
+            )
+
+        markdown = result.markdown_result or ""
+        logger.info("GlmOcrConverter: 图片 OCR 识别完成, 输出长度=%d", len(markdown))
+        return DocumentConverterResult(markdown=markdown)
+
+    def _convert_pdf(self, file_stream: BinaryIO) -> DocumentConverterResult:
+        pdf_stream = io.BytesIO(file_stream.read())
+        pdf_bytes = pdf_stream.getvalue()  # Keep original bytes for batch OCR
+        markdown_parts = []
+
+        with pdfplumber.open(pdf_stream) as pdf:
+            total_pages = len(pdf.pages)
+            logger.info("GlmOcrConverter: 开始处理 PDF, 总页数=%d", total_pages)
+
+            # Optimization: detect if entire PDF is scanned
+            all_scanned = self._detect_all_scanned(pdf)
+
+            if all_scanned and not self.force_ai:
+                # Batch mode: upload entire PDF to glmocr SDK (single API call)
+                logger.info(
+                    "GlmOcrConverter: 全文档扫描模式, 批量上传PDF, 页数=%d",
+                    total_pages,
+                )
+                try:
+                    markdown = self._convert_pdf_batch(pdf_bytes)
+                    if markdown.strip():
+                        logger.info(
+                            "GlmOcrConverter: 批量OCR完成, 输出长度=%d",
+                            len(markdown),
+                        )
+                        return DocumentConverterResult(markdown=markdown)
+                except Exception as e:
+                    logger.error(
+                        "GlmOcrConverter: 批量OCR失败, 抛出异常让框架fallback到下一个converter, 错误=%s",
+                        e,
+                    )
+                    raise
+
+            # Per-page processing (PAGE_BY_PAGE mode or batch failed)
+            for page_num, page in enumerate(pdf.pages):
+                # Choose processing method
+                if self.force_ai or all_scanned:
+                    # All scanned (after batch failed) or force_ai
+                    logger.info(
+                        "GlmOcrConverter: 第 %d/%d 页, 使用 glmocr OCR",
+                        page_num + 1,
+                        total_pages,
+                    )
+                    try:
+                        markdown = self._convert_with_glmocr(page, page_num)
+                    except Exception as e:
+                        logger.error(
+                            "GlmOcrConverter: 第 %d/%d 页识别异常, 错误=%s",
+                            page_num + 1,
+                            e,
+                        )
+                        raise
+                else:
+                    # Per-page analysis (PAGE_BY_PAGE mode or non-scanned doc)
+                    page_type = self._analyze_page(page)
+
+                    if page_type != "plain_text":
+                        logger.info(
+                            "GlmOcrConverter: 第 %d/%d 页, 类型=%s, 使用 glmocr OCR",
+                            page_num + 1,
+                            total_pages,
+                            page_type,
+                        )
+                        try:
+                            markdown = self._convert_with_glmocr(page, page_num)
+                        except Exception as e:
+                            logger.error(
+                                "GlmOcrConverter: 第 %d/%d 页识别异常, 错误=%s",
+                                page_num + 1,
+                                e,
+                            )
+                            raise
+                    else:
+                        logger.info(
+                            "GlmOcrConverter: 第 %d/%d 页, 类型=%s, 使用 pdfplumber",
+                            page_num + 1,
+                            total_pages,
+                            page_type,
+                        )
+                        markdown = self._extract_text_with_tables(page)
+
+                if markdown.strip():
+                    markdown_parts.append(f"## Page {page_num + 1}\n\n{markdown}")
+
+                page.close()
+
+        markdown = "\n\n".join(markdown_parts).strip()
+        logger.info("GlmOcrConverter: PDF 转换完成, 输出长度=%d", len(markdown))
+        return DocumentConverterResult(markdown=markdown)
+
+    def _convert_pdf_batch(self, pdf_bytes: bytes) -> str:
+        """Convert entire PDF in a single API call.
+
+        More efficient for scanned PDFs: one API call instead of N calls for N pages.
+
+        Args:
+            pdf_bytes: Raw PDF file content.
+
+        Returns:
+            Markdown text from all pages.
+        """
+        logger.info(
+            "GlmOcrConverter: 批量上传PDF到glmocr SDK, 大小=%d bytes", len(pdf_bytes)
+        )
+        result = self._get_glmocr().parse(pdf_bytes)
+
+        # Check for errors
+        d = result.to_dict()
+        if "error" in d:
+            logger.error(
+                "GlmOcrConverter: 批量OCR返回错误, 错误=%s",
+                d["error"],
+            )
+            raise RuntimeError(
+                f"GlmOcrConverter: glmocr SDK batch OCR error: {d['error']}"
+            )
+
+        markdown = result.markdown_result or ""
+        return markdown
+
+    def _analyze_page(self, page: Any) -> str:
+        """Analyze page content type."""
+        # Check for images
+        if hasattr(page, "images") and page.images:
+            return "complex"
+
+        # Check for tables
+        tables = page.find_tables()
+        if tables:
+            return "complex"
+
+        # Check for graphics/curves
+        if hasattr(page, "curves") and page.curves:
+            return "complex"
+
+        return "plain_text"
+
+    def _is_scanned_page(self, page: Any) -> bool:
+        """Check if a page is likely a scanned image.
+
+        A page is considered scanned if:
+        1. It contains images, AND
+        2. It has very little extractable text (below threshold)
+
+        Args:
+            page: pdfplumber page object
+
+        Returns:
+            True if the page appears to be a scanned image
+        """
+        # Must have images to be a scan
+        has_images = hasattr(page, "images") and bool(page.images)
+        if not has_images:
+            return False
+
+        # Check extractable text length
+        try:
+            text = page.extract_text() or ""
+            text_len = len(text.strip())
+            # If there's substantial text, it might be a mixed page or
+            # a digital PDF with embedded images
+            if text_len >= self.scan_text_threshold:
+                return False
+        except Exception:
+            # If text extraction fails, assume it's a scan
+            return True
+
+        return True
+
+    def _detect_all_scanned(self, pdf: Any) -> bool:
+        """Detect if entire PDF is scanned based on scan_detection_mode.
+
+        Optimization: When first few pages are scanned, we can assume
+        all pages are scanned and skip per-page analysis.
+
+        Args:
+            pdf: pdfplumber PDF object
+
+        Returns:
+            True if entire PDF should be treated as scanned
+        """
+        if self.scan_detection_mode == ScanDetectionMode.PAGE_BY_PAGE:
+            return False
+
+        total_pages = len(pdf.pages)
+        if total_pages == 0:
+            return False
+
+        if self.scan_detection_mode == ScanDetectionMode.FIRST_PAGE_HINT:
+            # Check only first page
+            first_page = pdf.pages[0]
+            is_scanned = self._is_scanned_page(first_page)
+            first_page.close()
+            if is_scanned:
+                logger.info(
+                    "GlmOcrConverter: 首页检测为扫描件, 模式=FIRST_PAGE_HINT, 全文档使用OCR"
+                )
+            return is_scanned
+
+        if self.scan_detection_mode == ScanDetectionMode.SAMPLING:
+            # Sample first N pages
+            sample_count = min(self.scan_sample_pages, total_pages)
+            scanned_count = 0
+
+            for i in range(sample_count):
+                page = pdf.pages[i]
+                if self._is_scanned_page(page):
+                    scanned_count += 1
+
+            # If majority of sampled pages are scanned, treat all as scanned
+            majority_threshold = sample_count // 2 + 1
+            all_scanned = scanned_count >= majority_threshold
+
+            if all_scanned:
+                logger.info(
+                    "GlmOcrConverter: 抽样检测 %d/%d 页为扫描件, 模式=SAMPLING, 全文档使用OCR",
+                    scanned_count,
+                    sample_count,
+                )
+
+            return all_scanned
+
+        return False
+
+    def _convert_with_glmocr(self, page: Any, page_num: int) -> str:
+        """Convert page using glmocr SDK.
+
+        Raises RuntimeError on OCR failure so the framework can try the next converter.
+        """
+        # Render page to image
+        img = page.to_image(resolution=150)
+        img_bytes = io.BytesIO()
+        img.save(img_bytes, format="PNG")
+
+        logger.info("GlmOcrConverter: glmocr SDK 开始识别第 %d 页", page_num + 1)
+        try:
+            result = self._get_glmocr().parse(img_bytes.getvalue())
+        except Exception as e:
+            logger.error(
+                "GlmOcrConverter: glmocr SDK 第 %d 页识别异常, 错误=%s", page_num + 1, e
+            )
+            raise
+
+        # Check for errors
+        d = result.to_dict()
+        if "error" in d:
+            logger.error(
+                "GlmOcrConverter: glmocr SDK 第 %d 页返回错误, 错误=%s",
+                page_num + 1,
+                d["error"],
+            )
+            raise RuntimeError(
+                f"GlmOcrConverter: glmocr SDK returned error on page {page_num + 1}: {d['error']}"
+            )
+
+        markdown = result.markdown_result or ""
+        logger.info(
+            "GlmOcrConverter: glmocr SDK 第 %d 页识别完成, 输出长度=%d",
+            page_num + 1,
+            len(markdown),
+        )
+        return markdown
+
+    def _extract_text_with_tables(self, page: Any) -> str:
+        """Extract text and tables from page."""
+        parts = []
+
+        # Extract text
+        text = page.extract_text() or ""
+        if text.strip():
+            parts.append(text.strip())
+
+        # Extract tables
+        try:
+            tables = page.extract_tables()
+            if tables:
+                for table in tables:
+                    if table:
+                        md_table = self._table_to_markdown(table)
+                        if md_table.strip():
+                            parts.append(md_table)
+        except Exception:
+            pass
+
+        return "\n\n".join(parts)
+
+    def _table_to_markdown(self, table: list[list[str]]) -> str:
+        """Convert table to Markdown."""
+        if not table:
+            return ""
+
+        # Filter None values
+        table = [[cell if cell is not None else "" for cell in row] for row in table]
+
+        # Filter empty rows
+        table = [row for row in table if any(cell.strip() for cell in row)]
+
+        if not table:
+            return ""
+
+        # Calculate column widths
+        col_widths = [
+            max(len(str(row[i])) if i < len(row) else 0 for row in table)
+            for i in range(max(len(row) for row in table))
+        ]
+
+        # Format table
+        lines = []
+        for row_idx, row in enumerate(table):
+            padded_row = row + [""] * (len(col_widths) - len(row))
+            line = (
+                "| "
+                + " | ".join(
+                    str(cell).ljust(width)
+                    for cell, width in zip(padded_row, col_widths)
+                )
+                + " |"
+            )
+            lines.append(line)
+
+            if row_idx == 0:
+                sep = "|" + "|".join("-" * (w + 2) for w in col_widths) + "|"
+                lines.append(sep)
+
+        return "\n".join(lines)
+
+    def close(self):
+        """Close the GlmOcr instance."""
+        if self._glmocr:
+            self._glmocr.close()
+            self._glmocr = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()

{markitdown_glmocr-0.1.0 → markitdown_glmocr-0.2.2}/src/markitdown_glmocr/_plugin.py

@@ -1,33 +1,46 @@
 """Plugin registration for markitdown-glmocr."""
 
+import logging
 from typing import Any
+
 from markitdown import MarkItDown
 
 from ._converter import GlmOcrConverter
 
-
 __plugin_interface_version__ = 1
 
+logger = logging.getLogger(__name__)
+
 
 def register_converters(markitdown: MarkItDown, **kwargs: Any) -> None:
     """
     Register markitdown-glmocr converter.
-    
+
     Config sources (priority high to low):
     1. kwargs parameters
     2. Environment variables (ZHIPU_API_KEY)
     3. .env file
     4. Built-in defaults
     """
+    logger.info("markitdown-glmocr: 开始注册插件")
+
     # Register converter
+    # Priority -1.0: same level as PaddleOcrConverter,
+    # the upper-level agent's skills control which plugin to call first.
     PRIORITY_GLMOCR = -1.0
-    
-    markitdown.register_converter(
-        GlmOcrConverter(
+
+    try:
+        converter = GlmOcrConverter(
             api_key=kwargs.get("api_key"),
             timeout=kwargs.get("timeout", 1800),
             enable_layout=kwargs.get("enable_layout", False),
             force_ai=kwargs.get("force_ai", False),
-        ),
-        priority=PRIORITY_GLMOCR,
-    )
+        )
+        markitdown.register_converter(
+            converter,
+            priority=PRIORITY_GLMOCR,
+        )
+        logger.info("markitdown-glmocr: 插件注册成功, priority=%.1f", PRIORITY_GLMOCR)
+    except Exception as e:
+        logger.error("markitdown-glmocr: 插件注册失败, 错误=%s", e)
+        raise

markitdown_glmocr-0.1.0/src/markitdown_glmocr/__about__.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"

markitdown_glmocr-0.1.0/src/markitdown_glmocr/_config.py

@@ -1,25 +0,0 @@
-"""Configuration for markitdown-glmocr."""
-
-from dataclasses import dataclass, field
-
-
-@dataclass
-class GlmOcrConfig:
-    """markitdown-glmocr configuration.
-    
-    Configuration priority (high to low):
-    1. Constructor kwargs
-    2. Environment variables
-    3. .env file
-    4. Built-in defaults
-    """
-    
-    # API configuration
-    api_key: str = ""  # Reads from ZHIPU_API_KEY by default
-    
-    # OCR configuration
-    timeout: int = 1800
-    enable_layout: bool = False
-    
-    # Processing strategy
-    force_ai: bool = False

markitdown_glmocr-0.1.0/src/markitdown_glmocr/_converter.py

@@ -1,304 +0,0 @@
-"""GlmOcr PDF/Image Converter - Intelligent PDF and Image to Markdown conversion."""
-
-import io
-import sys
-from typing import Any, BinaryIO, Optional
-
-from markitdown import DocumentConverter, DocumentConverterResult, StreamInfo
-from markitdown._exceptions import MissingDependencyException, MISSING_DEPENDENCY_MESSAGE
-
-from ._config import GlmOcrConfig
-
-# Import dependencies
-_dependency_exc_info = None
-try:
-    import pdfminer
-    import pdfminer.high_level
-    import pdfplumber
-except ImportError:
-    _dependency_exc_info = sys.exc_info()
-
-# glmocr SDK
-try:
-    import glmocr
-    from glmocr import GlmOcr
-except ImportError:
-    glmocr = None
-    GlmOcr = None
-
-
-ACCEPTED_MIME_TYPE_PREFIXES = [
-    "application/pdf",
-    "application/x-pdf",
-    "image/jpeg",
-    "image/png",
-]
-
-ACCEPTED_FILE_EXTENSIONS = [".pdf", ".jpg", ".jpeg", ".png"]
-
-
-class GlmOcrConverter(DocumentConverter):
-    """
-    Intelligent PDF/Image converter using glmocr SDK.
-    
-    Features:
-    - Auto-detect page content type (plain text vs images/tables)
-    - Plain text pages use pdfplumber/pdfminer (fast, free)
-    - Complex pages use glmocr SDK for AI-powered OCR
-    - Image files (PNG, JPG) use glmocr SDK directly
-    - One-liner: glmocr.parse("document.pdf") handles everything
-    """
-
-    def __init__(
-        self,
-        api_key: Optional[str] = None,
-        timeout: int = 1800,
-        enable_layout: bool = False,
-        force_ai: bool = False,
-        config: Optional[GlmOcrConfig] = None,
-    ):
-        """
-        Initialize converter.
-
-        Args:
-            api_key: Zhipu API key (reads from ZHIPU_API_KEY env var if not provided)
-            timeout: Request timeout in seconds (default: 1800)
-            enable_layout: Enable layout detection (default: False)
-            force_ai: Force all pages to use AI (default: False)
-            config: Optional GlmOcrConfig instance
-        """
-        if glmocr is None:
-            raise ImportError(
-                "glmocr is required. Install with: pip install markitdown-glmocr[glmocr]"
-            )
-        
-        # Use config if provided
-        if config:
-            self.api_key = api_key or config.api_key
-            self.timeout = timeout if timeout != 1800 else config.timeout
-            self.enable_layout = enable_layout if enable_layout else config.enable_layout
-            self.force_ai = force_ai or config.force_ai
-        else:
-            self.api_key = api_key
-            self.timeout = timeout
-            self.enable_layout = enable_layout
-            self.force_ai = force_ai
-        
-        # Lazy init GlmOcr instance
-        self._glmocr: Optional[GlmOcr] = None
-
-    def _get_glmocr(self) -> GlmOcr:
-        """Get or create GlmOcr instance."""
-        if self._glmocr is None:
-            kwargs = {"timeout": self.timeout, "enable_layout": self.enable_layout}
-            if self.api_key:
-                kwargs["api_key"] = self.api_key
-            self._glmocr = GlmOcr(**kwargs)
-        return self._glmocr
-
-    def accepts(
-        self,
-        file_stream: BinaryIO,
-        stream_info: StreamInfo,
-        **kwargs: Any,
-    ) -> bool:
-        mimetype = (stream_info.mimetype or "").lower()
-        extension = (stream_info.extension or "").lower()
-
-        if extension in ACCEPTED_FILE_EXTENSIONS:
-            return True
-
-        for prefix in ACCEPTED_MIME_TYPE_PREFIXES:
-            if mimetype.startswith(prefix):
-                return True
-
-        return False
-
-    def convert(
-        self,
-        file_stream: BinaryIO,
-        stream_info: StreamInfo,
-        **kwargs: Any,
-    ) -> DocumentConverterResult:
-        if _dependency_exc_info is not None:
-            raise MissingDependencyException(
-                MISSING_DEPENDENCY_MESSAGE.format(
-                    converter=type(self).__name__,
-                    extension=".pdf",
-                    feature="pdf",
-                )
-            ) from _dependency_exc_info[1].with_traceback(
-                _dependency_exc_info[2]
-            )
-
-        extension = (stream_info.extension or "").lower()
-
-        # Image files: use glmocr directly
-        if extension in (".jpg", ".jpeg", ".png"):
-            return self._convert_image(file_stream, extension)
-
-        # PDF files: use hybrid approach
-        return self._convert_pdf(file_stream)
-
-    def _convert_image(self, file_stream: BinaryIO, extension: str = ".png") -> DocumentConverterResult:
-        """Convert image file using glmocr SDK."""
-        img_bytes = file_stream.read()
-
-        try:
-            result = self._get_glmocr().parse(img_bytes)
-
-            # Check for errors
-            d = result.to_dict()
-            if "error" in d:
-                return DocumentConverterResult(markdown="")
-
-            return DocumentConverterResult(
-                markdown=result.markdown_result or ""
-            )
-        except Exception as e:
-            return DocumentConverterResult(
-                markdown=f"<!-- Error converting image: {e} -->"
-            )
-
-    def _convert_pdf(self, file_stream: BinaryIO) -> DocumentConverterResult:
-        pdf_stream = io.BytesIO(file_stream.read())
-        markdown_parts = []
-
-        try:
-            with pdfplumber.open(pdf_stream) as pdf:
-                for page_num, page in enumerate(pdf.pages):
-                    # Analyze page type
-                    page_type = self._analyze_page(page)
-
-                    # Choose processing method
-                    if self.force_ai or page_type != "plain_text":
-                        # Complex content: use glmocr
-                        markdown = self._convert_with_glmocr(page, page_num)
-                    else:
-                        # Plain text: use pdfplumber
-                        markdown = self._extract_text_with_tables(page)
-
-                    if markdown.strip():
-                        markdown_parts.append(f"## Page {page_num + 1}\n\n{markdown}")
-
-                    page.close()
-
-            markdown = "\n\n".join(markdown_parts).strip()
-
-        except Exception:
-            # Fallback to pdfminer
-            pdf_stream.seek(0)
-            markdown = pdfminer.high_level.extract_text(pdf_stream) or ""
-
-        # Final fallback
-        if not markdown:
-            pdf_stream.seek(0)
-            markdown = pdfminer.high_level.extract_text(pdf_stream) or ""
-
-        return DocumentConverterResult(markdown=markdown)
-
-    def _analyze_page(self, page: Any) -> str:
-        """Analyze page content type."""
-        # Check for images
-        if hasattr(page, "images") and page.images:
-            return "complex"
-        
-        # Check for tables
-        tables = page.find_tables()
-        if tables:
-            return "complex"
-        
-        # Check for graphics/curves
-        if hasattr(page, "curves") and page.curves:
-            return "complex"
-        
-        return "plain_text"
-
-    def _convert_with_glmocr(self, page: Any, page_num: int) -> str:
-        """Convert page using glmocr SDK."""
-        try:
-            # Render page to image
-            img = page.to_image(resolution=150)
-            img_bytes = io.BytesIO()
-            img.save(img_bytes, format="PNG")
-            result = self._get_glmocr().parse(img_bytes.getvalue())
-            
-            # Check for errors
-            d = result.to_dict()
-            if "error" in d:
-                return self._extract_text_with_tables(page)
-            
-            return result.markdown_result or ""
-            
-        except Exception:
-            return self._extract_text_with_tables(page)
-
-    def _extract_text_with_tables(self, page: Any) -> str:
-        """Extract text and tables from page."""
-        parts = []
-
-        # Extract text
-        text = page.extract_text() or ""
-        if text.strip():
-            parts.append(text.strip())
-
-        # Extract tables
-        try:
-            tables = page.extract_tables()
-            if tables:
-                for table in tables:
-                    if table:
-                        md_table = self._table_to_markdown(table)
-                        if md_table.strip():
-                            parts.append(md_table)
-        except Exception:
-            pass
-
-        return "\n\n".join(parts)
-
-    def _table_to_markdown(self, table: list[list[str]]) -> str:
-        """Convert table to Markdown."""
-        if not table:
-            return ""
-
-        # Filter None values
-        table = [[cell if cell is not None else "" for cell in row] for row in table]
-
-        # Filter empty rows
-        table = [row for row in table if any(cell.strip() for cell in row)]
-
-        if not table:
-            return ""
-
-        # Calculate column widths
-        col_widths = [
-            max(len(str(row[i])) if i < len(row) else 0 for row in table)
-            for i in range(max(len(row) for row in table))
-        ]
-
-        # Format table
-        lines = []
-        for row_idx, row in enumerate(table):
-            padded_row = row + [""] * (len(col_widths) - len(row))
-            line = "| " + " | ".join(
-                str(cell).ljust(width) for cell, width in zip(padded_row, col_widths)
-            ) + " |"
-            lines.append(line)
-
-            if row_idx == 0:
-                sep = "|" + "|".join("-" * (w + 2) for w in col_widths) + "|"
-                lines.append(sep)
-
-        return "\n".join(lines)
-    
-    def close(self):
-        """Close the GlmOcr instance."""
-        if self._glmocr:
-            self._glmocr.close()
-            self._glmocr = None
-    
-    def __enter__(self):
-        return self
-    
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()