markitdown-glmocr 0.1.0__py3-none-any.whl

markitdown_glmocr/__about__.py

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

markitdown_glmocr/__init__.py

@@ -0,0 +1,12 @@
+"""markitdown-glmocr: Intelligent PDF to Markdown converter using glmocr SDK."""
+
+from ._plugin import register_converters
+from ._config import GlmOcrConfig
+from ._converter import GlmOcrConverter
+
+__plugin_interface_version__ = 1
+__all__ = [
+    "register_converters",
+    "GlmOcrConfig",
+    "GlmOcrConverter",
+]

markitdown_glmocr/_config.py

@@ -0,0 +1,25 @@
+"""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/_converter.py

@@ -0,0 +1,304 @@
+"""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()

markitdown_glmocr/_plugin.py

@@ -0,0 +1,33 @@
+"""Plugin registration for markitdown-glmocr."""
+
+from typing import Any
+from markitdown import MarkItDown
+
+from ._converter import GlmOcrConverter
+
+
+__plugin_interface_version__ = 1
+
+
+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
+    """
+    # Register converter
+    PRIORITY_GLMOCR = -1.0
+    
+    markitdown.register_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_glmocr-0.1.0.dist-info/METADATA

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: markitdown-glmocr
+Version: 0.1.0
+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
+Project-URL: Source, https://github.com/microsoft/markitdown
+Author-email: Contributors <noreply@github.com>
+License-Expression: MIT
+Keywords: ai,glm-ocr,glmocr,llm,markitdown,ocr,pdf,vision
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: markitdown>=0.1.0
+Requires-Dist: pdfminer-six>=20251230
+Requires-Dist: pdfplumber>=0.11.9
+Requires-Dist: pillow>=9.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Provides-Extra: glmocr
+Requires-Dist: glmocr; extra == 'glmocr'
+Description-Content-Type: text/markdown
+
+# markitdown-glmocr
+
+智能 PDF 转 Markdown 插件，使用 glmocr SDK（智谱 GLM-OCR）驱动的图片和表格提取。
+
+## 特性
+
+- 🔍 **智能检测**：自动识别每页内容类型（纯文本 vs 图片/表格）
+- 📄 **默认解析**：纯文本页面使用 pdfplumber/pdfminer 提取，速度快、成本低
+- 🤖 **AI 增强**：复杂页面（图片、表格）使用 glmocr SDK 转换为 Markdown
+- ⚡ **一行调用**：`glmocr.parse("document.pdf")` 完成 OCR，无需手动截图编码
+- 📊 **结构化输出**：返回 Markdown + JSON 结构（含区域标签、边界框）
+
+## 安装
+
+```bash
+# 基础安装
+pip install markitdown-glmocr
+
+# 安装 AI 功能
+pip install markitdown-glmocr[glmocr]
+```
+
+## 配置
+
+### 环境变量（推荐）
+
+```bash
+# 必需：智谱 API Key
+export ZHIPU_API_KEY="your-zhipu-api-key"
+
+# 可选
+export GLMOCR_MODEL="glm-ocr"          # 模型名称
+export GLMOCR_TIMEOUT="600"             # 请求超时（秒）
+export GLMOCR_ENABLE_LAYOUT="true"      # 启用布局检测
+export GLMOCR_LOG_LEVEL="INFO"          # 日志级别
+```
+
+### 配置优先级
+
+```
+构造函数参数 > 环境变量 > .env 文件 > config.yaml > 内置默认值
+```
+
+### 本地敏感配置
+
+```bash
+# 创建 .env 文件（自动读取）
+echo "ZHIPU_API_KEY=your-api-key" > .env
+```
+
+## 使用方法
+
+### 命令行（推荐）
+
+```bash
+# 1. 设置 API Key
+export ZHIPU_API_KEY="sk-xxx"
+
+# 2. 查看已安装插件
+markitdown --list-plugins
+
+# 3. 使用插件转换 PDF
+markitdown -p document.pdf
+
+# 4. 保存到文件
+markitdown -p document.pdf -o output.md
+```
+
+### Python API
+
+```python
+from markitdown import MarkItDown
+from markitdown_glmocr import GlmOcrConverter
+
+# 方式1：自动从环境变量读取 ZHIPU_API_KEY
+converter = GlmOcrConverter()
+md = MarkItDown(enable_plugins=False)
+md.register_converter(converter, priority=-1.0)
+result = md.convert("document.pdf")
+print(result.markdown)
+
+# 方式2：手动传入 API Key
+converter = GlmOcrConverter(api_key="sk-xxx")
+md = MarkItDown(enable_plugins=False)
+md.register_converter(converter, priority=-1.0)
+result = md.convert("document.pdf")
+print(result.markdown)
+
+# 方式3：直接使用 glmocr SDK（更简单）
+import glmocr
+result = glmocr.parse("document.pdf")
+print(result.markdown_result)  # Markdown 输出
+print(result.json_result)      # 结构化 JSON（区域标签、边界框）
+```
+
+### 处理结果
+
+```python
+import glmocr
+
+result = glmocr.parse("report.pdf")
+
+# 获取 Markdown
+print(result.markdown_result)
+
+# 获取结构化数据（按页分组）
+for page_idx, page_regions in enumerate(result.json_result):
+    print(f"Page {page_idx + 1}: {len(page_regions)} regions")
+    for region in page_regions:
+        print(f"  [{region['label']}] {region['content'][:60]}")
+
+# 按标签筛选
+tables = [r for r in result.json_result[0] if r["label"] == "table"]
+formulas = [r for r in result.json_result[0] if r["label"] == "formula"]
+
+# 保存到磁盘
+result.save(output_dir="./output")
+```
+
+## 配置选项
+
+### GlmOcrConverter 参数
+
+| 参数 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `api_key` | str | 环境变量 `ZHIPU_API_KEY` | 智谱 API Key |
+| `timeout` | int | 1800 | 请求超时（秒） |
+| `enable_layout` | bool | False | 启用布局检测 |
+| `force_ai` | bool | False | 强制所有页面使用 AI |
+
+### 环境变量
+
+| 变量 | 说明 | 示例 |
+|------|------|------|
+| `ZHIPU_API_KEY` | API Key（必需） | `sk-abc123` |
+| `GLMOCR_MODEL` | 模型名称 | `glm-ocr` |
+| `GLMOCR_TIMEOUT` | 请求超时（秒） | `600` |
+| `GLMOCR_ENABLE_LAYOUT` | 布局检测 | `true` |
+| `GLMOCR_LOG_LEVEL` | 日志级别 | `INFO` |
+
+## 工作原理
+
+```
+PDF 输入
+    │
+    ▼
+逐页分析内容类型
+    │
+    ├─ 纯文本页面 ──► pdfplumber 提取文本
+    │
+    └─ 复杂页面（图片/表格）
+          │
+          └─► glmocr.parse() 一行调用
+                │
+                ├─ 内置截图渲染
+                ├─ 内置 base64 编码
+                └─ 内置 OCR 识别
+    │
+    ▼
+合并输出完整 Markdown
+```
+
+## 区域标签（json_result）
+
+glmocr SDK 返回的结构化数据支持以下标签：
+
+| 标签 | 说明 |
+|------|------|
+| `title` | 标题 |
+| `text` | 正文文本 |
+| `table` | 表格 |
+| `figure` | 图片 |
+| `formula` | 公式 |
+| `header` | 页眉 |
+| `footer` | 页脚 |
+| `page_number` | 页码 |
+| `reference` | 参考文献 |
+| `seal` | 印章 |
+
+## 技术架构
+
+- **glmocr**: 智谱 OCR SDK，一行代码完成 PDF/图片解析
+- **pdfplumber**: PDF 页面分析和纯文本提取
+- **pdfminer**: 纯文本页面提取备用
+
+## 依赖
+
+- `markitdown>=0.1.0` - 基础框架
+- `pdfplumber>=0.11.9` - PDF 解析和截图
+- `pdfminer.six>=20251230` - 文本提取备用
+- `Pillow>=9.0.0` - 图像处理
+- `glmocr` - 智谱 OCR SDK（可选，AI 功能需要）
+
+## 许可证
+
+MIT

markitdown_glmocr-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+markitdown_glmocr/__about__.py,sha256=QTYqXqSTHFRkM9TEgpDFcHvwLbvqHDqvqfQ9EiXkcAM,23
+markitdown_glmocr/__init__.py,sha256=wQfsyeo8WQbF8cARbtIWgYysGJCVXHT9nijia2onuI8,325
+markitdown_glmocr/_config.py,sha256=QASW-I7n7ctCRXMwtCsewyxWSt8YQt8rVfQN75wrC6g,566
+markitdown_glmocr/_converter.py,sha256=cj5gQs_Yi5VHxMdDpBMsvBCnWhyKQO9ZbORCCo3jLVs,9953
+markitdown_glmocr/_plugin.py,sha256=khzqfGLj91eaLlV7g7epQSYiVEy8Jgh9lVTsLw5gNUQ,880
+markitdown_glmocr-0.1.0.dist-info/METADATA,sha256=ZNPudtIkbHaqAvwqJwhZBpmPG7Nf1y9gZ736qGVgolk,6015
+markitdown_glmocr-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+markitdown_glmocr-0.1.0.dist-info/entry_points.txt,sha256=RuVnDvfZHzj1V8wBvEj74xhS5YLWQhtDAgCzbOBXxwY,58
+markitdown_glmocr-0.1.0.dist-info/RECORD,,

markitdown_glmocr-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

markitdown_glmocr-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[markitdown.plugin]
+markitdown_glmocr = markitdown_glmocr