kreuzberg 3.6.2__py3-none-any.whl → 3.8.0__py3-none-any.whl

{kreuzberg-3.6.2.dist-info → kreuzberg-3.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kreuzberg
-Version: 3.6.2
+Version: 3.8.0
 Summary: A text extraction library supporting PDFs, images, office documents and more
 Project-URL: homepage, https://github.com/Goldziher/kreuzberg
 Author-email: Na'aman Hirschfeld <nhirschfed@gmail.com>
@@ -23,9 +23,10 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: anyio>=4.9.0
-Requires-Dist: charset-normalizer>=3.4.2
+Requires-Dist: chardetng-py>=0.3.4
 Requires-Dist: exceptiongroup>=1.2.2; python_version < '3.11'
-Requires-Dist: html-to-markdown[lxml]>=1.6.0
+Requires-Dist: html-to-markdown[lxml]>=1.8.0
+Requires-Dist: mcp>=1.11.0
 Requires-Dist: msgspec>=0.18.0
 Requires-Dist: playa-pdf>=0.6.1
 Requires-Dist: psutil>=7.0.0
@@ -33,6 +34,9 @@ Requires-Dist: pypdfium2==4.30.0
 Requires-Dist: python-calamine>=0.3.2
 Requires-Dist: python-pptx>=1.0.2
 Requires-Dist: typing-extensions>=4.14.0; python_version < '3.12'
+Provides-Extra: additional-extensions
+Requires-Dist: mailparse>=1.0.15; extra == 'additional-extensions'
+Requires-Dist: tomli>=2.0.0; (python_version < '3.11') and extra == 'additional-extensions'
 Provides-Extra: all
 Requires-Dist: click>=8.2.1; extra == 'all'
 Requires-Dist: easyocr>=1.7.2; extra == 'all'
@@ -40,6 +44,7 @@ Requires-Dist: fast-langdetect>=0.3.2; extra == 'all'
 Requires-Dist: gmft>=0.4.2; extra == 'all'
 Requires-Dist: keybert>=0.9.0; extra == 'all'
 Requires-Dist: litestar[opentelemetry,standard,structlog]>=2.16.0; extra == 'all'
+Requires-Dist: mailparse>=1.0.15; extra == 'all'
 Requires-Dist: paddleocr>=3.1.0; extra == 'all'
 Requires-Dist: paddlepaddle>=3.1.0; extra == 'all'
 Requires-Dist: rich>=14.0.0; extra == 'all'
@@ -76,21 +81,51 @@ Description-Content-Type: text/markdown
 [![PyPI version](https://badge.fury.io/py/kreuzberg.svg)](https://badge.fury.io/py/kreuzberg)
 [![Documentation](https://img.shields.io/badge/docs-GitHub_Pages-blue)](https://goldziher.github.io/kreuzberg/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Test Coverage](https://img.shields.io/badge/coverage-95%25-green)](https://github.com/Goldziher/kreuzberg)
 
-**High-performance Python library for text extraction from documents.** Extract text from PDFs, images, office documents, and more with both async and sync APIs.
+**High-performance Open Source Document Intelligence framework for Python.** Built by engineers for production workloads - extract text from any document with excellent performance and minimal complexity.
 
 📖 **[Complete Documentation](https://goldziher.github.io/kreuzberg/)**
 
-## Why Kreuzberg?
+## Why Choose Kreuzberg?
 
-- **🚀 Fastest Performance**: [35+ files/second](https://goldziher.github.io/python-text-extraction-libs-benchmarks/) - the fastest text extraction library
-- **💾 Memory Efficient**: 14x smaller than alternatives (71MB vs 1GB+) with lowest memory usage (~530MB)
-- **⚡ Dual APIs**: Only library with both sync and async support
-- **🔧 Zero Configuration**: Works out of the box with sane defaults
-- **🏠 Local Processing**: No cloud dependencies or external API calls
-- **📦 Rich Format Support**: PDFs, images, Office docs, HTML, and more
-- **🔍 Multiple OCR Engines**: Tesseract, EasyOCR, and PaddleOCR support
-- **🐳 Production Ready**: CLI, REST API, and Docker images included
+### 🚀 Performance
+
+- [benchmarked as the fastest framework](https://goldziher.github.io/python-text-extraction-libs-benchmarks/) - 2-3x faster than the nearest alternatives
+- Minimal footprint: 71MB install vs 1GB+ for competitors
+- Lowest memory usage (~530MB average) optimized for production workloads
+- Edge and serverless ready - deploy anywhere without heavy dependencies
+
+### 🛠️ Engineering Quality
+
+- Built by software engineers with modern Python best practices
+- 95%+ test coverage with comprehensive test suite
+- Thoroughly benchmarked and profiled for real-world performance
+- Only framework offering true async/await support alongside sync APIs
+- Robust error handling and detailed logging
+
+### 🎯 Developer Experience
+
+- Works out of the box with sane defaults, scales with your needs
+- Native MCP server for AI tool integration (Claude Desktop, Cursor)
+- Full type safety with excellent IDE support (completions)
+- Comprehensive documentation including full API reference
+
+### 🌍 Deployment Options
+
+- Docker images for all architectures (AMD64, ARM64)
+- Cloud native - AWS Lambda, Google Cloud Functions, Azure Functions
+- CPU-only processing - no GPU requirements, lower energy consumption
+- 100% local processing - no external API dependencies
+- Multiple deployment modes: CLI, REST API, MCP server
+
+### 🎯 Complete Solution
+
+- Universal format support: PDFs, images, Office docs, HTML, spreadsheets, presentations
+- Multiple OCR engines: Tesseract, EasyOCR, PaddleOCR with intelligent fallbacks
+- Advanced features: Table extraction, metadata extraction, content chunking for RAG
+- Production tools: REST API, CLI tools, batch processing, custom extractors
+- Fully extensible: Add your own extractors
 
 ## Quick Start
 
@@ -136,6 +171,55 @@ asyncio.run(main())
 
 ## Deployment Options
 
+### 🤖 MCP Server (AI Integration)
+
+**Connect directly to Claude Desktop, Cursor, and other AI tools with the Model Context Protocol:**
+
+```bash
+# Install and run MCP server with all features (recommended)
+pip install "kreuzberg[all]"
+kreuzberg-mcp
+
+# Or with uvx (recommended for Claude Desktop)
+uvx --with "kreuzberg[all]" kreuzberg-mcp
+
+# Basic installation (core features only)
+pip install kreuzberg
+kreuzberg-mcp
+```
+
+**Configure in Claude Desktop (`claude_desktop_config.json`):**
+
+```json
+{
+  "mcpServers": {
+    "kreuzberg": {
+      "command": "uvx",
+      "args": ["--with", "kreuzberg[all]", "kreuzberg-mcp"]
+    }
+  }
+}
+```
+
+**Basic configuration (core features only):**
+
+```json
+{
+  "mcpServers": {
+    "kreuzberg": {
+      "command": "uvx",
+      "args": ["kreuzberg-mcp"]
+    }
+  }
+}
+```
+
+**Available MCP capabilities:**
+
+- **Tools**: `extract_document`, `extract_bytes`, `extract_simple`
+- **Resources**: Configuration, supported formats, OCR backends
+- **Prompts**: Extract-and-summarize, structured analysis workflows
+
 ### 🐳 Docker (Recommended)
 
 ```bash
@@ -146,7 +230,7 @@ docker run -p 8000:8000 goldziher/kreuzberg:latest
 curl -X POST http://localhost:8000/extract -F "data=@document.pdf"
 ```
 
-Available variants: `latest`, `3.6.1`, `3.6.1-easyocr`, `3.6.1-paddle`, `3.6.1-gmft`, `3.6.1-all`
+Available variants: `latest`, `v3.8.0`, `v3.8.0-easyocr`, `v3.8.0-paddle`, `v3.8.0-gmft`, `v3.8.0-all`
 
 ### 🌐 REST API
 
@@ -189,23 +273,28 @@ kreuzberg extract *.pdf --output-dir ./extracted/
 | **Web**           | HTML, XML, MHTML               |
 | **Archives**      | Support via extraction         |
 
-## Performance
+## 📊 Performance Comparison
+
+[Comprehensive benchmarks](https://goldziher.github.io/python-text-extraction-libs-benchmarks/) across 94 real-world documents • [View source](https://github.com/Goldziher/python-text-extraction-libs-benchmarks):
 
-**[Comprehensive benchmarks](https://goldziher.github.io/python-text-extraction-libs-benchmarks/)** across 94 real-world documents (~210MB) • [View source](https://github.com/Goldziher/python-text-extraction-libs-benchmarks):
+| Framework     | Speed       | Memory | Install Size | Dependencies | Success Rate |
+| ------------- | ----------- | ------ | ------------ | ------------ | ------------ |
+| **Kreuzberg** | 35+ files/s | 530MB  | 71MB         | 20           | High         |
+| Unstructured  | ~12 files/s | ~1GB   | 146MB        | 54           | 88%+         |
+| MarkItDown    | ~15 files/s | ~1.5GB | 251MB        | 25           | 80%\*        |
+| Docling       | ~1 file/min | ~5GB   | 1,032MB      | 88           | 45%\*        |
 
-| Library       | Speed           | Memory    | Install Size | Dependencies | Success Rate |
-| ------------- | --------------- | --------- | ------------ | ------------ | ------------ |
-| **Kreuzberg** | **35+ files/s** | **530MB** | **71MB**     | **20**       | High\*       |
-| Unstructured  | Moderate        | ~1GB      | 146MB        | 54           | 88%+         |
-| MarkItDown    | Good†           | ~1.5GB    | 251MB        | 25           | 80%†         |
-| Docling       | 60+ min/file‡   | ~5GB      | 1,032MB      | 88           | Low‡         |
+\*_Performance varies significantly with document complexity and size_
 
-\*_Can achieve 75% reliability with 15% performance trade-off when configured_
-†_Good on simple documents, struggles with large/complex files (>10MB)_
-‡_Frequently fails/times out on medium files (>1MB)_
+**Key strengths:**
 
-> **Benchmark details**: Tested across PDFs, Word docs, HTML, images, spreadsheets in 6 languages (English, Hebrew, German, Chinese, Japanese, Korean)
-> **Rule of thumb**: Use async API for complex documents and batch processing (up to 4.5x faster)
+- 2-3x faster processing than comparable frameworks
+- Smallest installation footprint and memory usage
+- Only framework with built-in async/await support
+- CPU-only processing - no GPU dependencies
+- Built by software engineers for production reliability
+
+> **Benchmark details**: Tests include PDFs, Word docs, HTML, images, and spreadsheets in multiple languages (English, Hebrew, German, Chinese, Japanese, Korean) on standardized hardware.
 
 ## Documentation
 
@@ -219,27 +308,6 @@ kreuzberg extract *.pdf --output-dir ./extracted/
 - [CLI Guide](https://goldziher.github.io/kreuzberg/cli/) - Command-line usage
 - [OCR Configuration](https://goldziher.github.io/kreuzberg/user-guide/ocr-configuration/) - OCR engine setup
 
-## Advanced Features
-
-- **📊 Table Extraction**: Extract tables from PDFs with GMFT
-- **🧩 Content Chunking**: Split documents for RAG applications
-- **🎯 Custom Extractors**: Extend with your own document handlers
-- **🔧 Configuration**: Flexible TOML-based configuration
-- **🪝 Hooks**: Pre/post-processing customization
-- **🌍 Multi-language OCR**: 100+ languages supported
-- **⚙️ Metadata Extraction**: Rich document metadata
-- **🔄 Batch Processing**: Efficient bulk document processing
-
 ## License
 
 MIT License - see [LICENSE](LICENSE) for details.
-
-______________________________________________________________________
-
-<div align="center">
-
-**[Documentation](https://goldziher.github.io/kreuzberg/) • [PyPI](https://pypi.org/project/kreuzberg/) • [Docker Hub](https://hub.docker.com/r/goldziher/kreuzberg) • [Benchmarks](https://github.com/Goldziher/python-text-extraction-libs-benchmarks) • [Discord](https://discord.gg/pXxagNK2zN)**
-
-Made with ❤️ by the [Kreuzberg contributors](https://github.com/Goldziher/kreuzberg/graphs/contributors)
-
-</div>

kreuzberg-3.8.0.dist-info/RECORD

@@ -0,0 +1,57 @@
+kreuzberg/__init__.py,sha256=wVxbug-w1cO2xHcP04Bf6QeIKmT2Ep6aeenb8EOYLA0,1534
+kreuzberg/__main__.py,sha256=s2qM1nPEkRHAQP-G3P7sf5l6qA_KJeIEHS5LpPz04lg,183
+kreuzberg/_chunker.py,sha256=2eHSRHcZdJ2ZjR3in49y3o9tPl5HMO3vkbnMqaVCbHI,1887
+kreuzberg/_cli_config.py,sha256=WD_seFjbuay_NJv77vGLBW6BVV9WZNujdzf3zQkhzPc,5691
+kreuzberg/_constants.py,sha256=Bxc8oiN-wHwnWXT9bEiJhTUcu1ygPpra5qHirAif3b4,191
+kreuzberg/_entity_extraction.py,sha256=EIasBGpkZ-3FwivjEpisz23LilTwx8os-IbfrDtzNl4,7815
+kreuzberg/_gmft.py,sha256=ZIEUu4Uy5zYNFEeDRbz1cLJhnCAStVsSzm1PQ3vDeO8,14828
+kreuzberg/_language_detection.py,sha256=22-uXoOu_ws0K8Hz2M7U_SF9QX3npRYLhntAE1dNLFU,3283
+kreuzberg/_mime_types.py,sha256=OhJ6gEyyLHjyvRtkk37zyLFBsRcSd_QybBaV8TxinIg,8471
+kreuzberg/_playa.py,sha256=rU6ii2Qnrj8tkDYlSiab5h-BCYLJnUg4QwSLVDEXF5g,11883
+kreuzberg/_registry.py,sha256=wGSlkS0U1zqruWQCLE95vj4a2mw1yyvf0j6rgz80sJg,3473
+kreuzberg/_types.py,sha256=R_0Xc2kq4nEwkruvkB3qfrLeJ996419hBQ_1C6Xrqjo,13388
+kreuzberg/cli.py,sha256=S0w2nGXBWPFn1NhxppW7dpUwB9f_3ymFuWSAB2aRu9g,12465
+kreuzberg/exceptions.py,sha256=xRaiJh11i8E6Nc-gAQPgNW5xvhiiFBhRS-CBbCEbHQM,2881
+kreuzberg/extraction.py,sha256=mdH45bMAAUUNXYT7UrNyWJ2oD_gXuLUU-NyuYxQM884,17459
+kreuzberg/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kreuzberg/_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kreuzberg/_api/main.py,sha256=kZCMPPzP4BGzEege9pdhQTJPKKVjCaC6kZdMMeaqP2M,2599
+kreuzberg/_extractors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kreuzberg/_extractors/_base.py,sha256=ECEwBpxnIy_J9kGZGuqsaPCgLFfxRn7kn4hIf11gDJ8,4478
+kreuzberg/_extractors/_email.py,sha256=6-Mk1TRXPyy9ylWKCpgdrogyzhiFnJOTuTRld1ghO8I,5695
+kreuzberg/_extractors/_html.py,sha256=lOM1Tgrrvd7vpEeFAxC1dp0Tibr6N2FEHCjgFx0FK64,1745
+kreuzberg/_extractors/_image.py,sha256=0kzOQTTeJacaA8I9833fFvVQSz6FtUe9Nuw1oy0ToD0,4939
+kreuzberg/_extractors/_pandoc.py,sha256=oQ4DgQSPoX1LXjGAKh_A40JHqiKWb91LeRBYSS_6EUA,26750
+kreuzberg/_extractors/_pdf.py,sha256=giYG3aEdmsxT0tGWKBaMzHDPz74-jVmK4HZARDEBhsM,17108
+kreuzberg/_extractors/_presentation.py,sha256=CUlqZl_QCdJdumsZh0BpROkFbvi9uq7yMoIt3bRTUeE,10859
+kreuzberg/_extractors/_spread_sheet.py,sha256=Nvyz7XT7C2ai4QeUashBeENQpuP5rs8SmKfumxEqlCg,13712
+kreuzberg/_extractors/_structured.py,sha256=i3jAvhHZt_BsRGgZZfgcsUqlwAg_RNc8vsuecb04T0c,5581
+kreuzberg/_mcp/__init__.py,sha256=8PYV-omC8Rln7Cove8C3rHu3d7sR1FuiwSBG1O7vkAE,92
+kreuzberg/_mcp/server.py,sha256=BQHeKI89aKf24BIE4n6m8r1rVA1Zgt6vM8Ki_OHuGnc,6780
+kreuzberg/_multiprocessing/__init__.py,sha256=X2BtgKmWhF1rl0JYg2gvoSUaozKExfsWh-RRNvzNoOs,202
+kreuzberg/_multiprocessing/gmft_isolated.py,sha256=ZfbhiL5bhBEJnibUSls3WV-FECrnU9VvKfq5O2foHcc,11191
+kreuzberg/_ocr/__init__.py,sha256=CC9Ob1t_ltTYUamK1ZtmkswfCYdn1B-Z0kPemsQU0xU,1439
+kreuzberg/_ocr/_base.py,sha256=lNT0Tin4hzbmaamqqySxvYEwNtrJB5gGlStrANQQcyc,1637
+kreuzberg/_ocr/_easyocr.py,sha256=90Dv1xaLXbpG7EtmRQE5ykvnhqZJR3xSFXlxFMCSVSI,13740
+kreuzberg/_ocr/_paddleocr.py,sha256=UvugDdZd7RojHUiFeBaI8aqz36ecegPLj2v6oT6c42g,13776
+kreuzberg/_ocr/_pool.py,sha256=Yb0l_GxnPsIWn3NA2FuBYEC8ipIqgwaYglUt0ltqSvk,10948
+kreuzberg/_ocr/_sync.py,sha256=cdLiH9hYqygzqW3LkibhrE6C8atin7mfTv_k3JJFE0k,18287
+kreuzberg/_ocr/_tesseract.py,sha256=KtenEIGL63gRhdH2hxOEVM89locAETGo2bNjQMXjTwY,13266
+kreuzberg/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kreuzberg/_utils/_cache.py,sha256=CtpSmEggWoIPDZ9_Nl0i5pr7wtPyci8EVT-ajYsARGI,13609
+kreuzberg/_utils/_device.py,sha256=rnaSSB5ibf2wr7EDxrcmOUZ4Ocor0pHkwb3N1pC46EY,10276
+kreuzberg/_utils/_document_cache.py,sha256=z8irioKsOu8xve1YgHatm__wIFvs9I1gDK3tLNsNyqM,6926
+kreuzberg/_utils/_errors.py,sha256=AV3oaRQDgJxe1YUZd9pCQUysUv9KW8Ib37MvnyFOZ4o,6386
+kreuzberg/_utils/_pdf_lock.py,sha256=nqxAYCNlfWDrJtP4ZNu57st1YnkDl-gYXdr0q8nv0kA,1961
+kreuzberg/_utils/_process_pool.py,sha256=E3bHOO67TeoLUBjtw5HoY9gyFl621VaImYI-_itQ96c,8653
+kreuzberg/_utils/_quality.py,sha256=dgFLt40NSqB8Ciej5QcZQLiV4U7LcrGux0vXckiE31U,7568
+kreuzberg/_utils/_serialization.py,sha256=Rt5zSkvzf1SVNDrI6F2Zvnkel24mQkD1QvP0WjgZUgk,2195
+kreuzberg/_utils/_string.py,sha256=5YKu9EZlZQ-LkphXUq8fdwKQrX9jWACFEhMGfjIysf4,6381
+kreuzberg/_utils/_sync.py,sha256=7LSavBmxVKQUzdjfx9fYRAI9IbJtRw8iGf_Q8B7RX9g,4923
+kreuzberg/_utils/_table.py,sha256=C2skLtcyczxDEH33Qw2dOwnR15SGillvNEP-NzBG3R8,8156
+kreuzberg/_utils/_tmp.py,sha256=hVn-VVijIg2FM7EZJ899gc7wZg-TGoJZoeAcxMX-Cxg,1044
+kreuzberg-3.8.0.dist-info/METADATA,sha256=d1N7v0EvJA-22g071Dctler5zF11WlKGTgLjGpsV8iw,11422
+kreuzberg-3.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kreuzberg-3.8.0.dist-info/entry_points.txt,sha256=GplGhFryCP7kyAG_k-Mdahznvo2fwi73qLFg5yQfH_A,91
+kreuzberg-3.8.0.dist-info/licenses/LICENSE,sha256=-8caMvpCK8SgZ5LlRKhGCMtYDEXqTKH9X8pFEhl91_4,1066
+kreuzberg-3.8.0.dist-info/RECORD,,

{kreuzberg-3.6.2.dist-info → kreuzberg-3.8.0.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 kreuzberg = kreuzberg.cli:cli
+kreuzberg-mcp = kreuzberg._mcp.server:main

kreuzberg/_multiprocessing/process_manager.py

@@ -1,189 +0,0 @@
-"""Process pool manager for resource-aware multiprocessing."""
-
-from __future__ import annotations
-
-import multiprocessing as mp
-from concurrent.futures import ProcessPoolExecutor
-from typing import TYPE_CHECKING, Any, TypeVar
-
-import anyio
-import psutil
-from typing_extensions import Self
-
-if TYPE_CHECKING:
-    import types
-    from collections.abc import Callable
-
-T = TypeVar("T")
-
-
-class ProcessPoolManager:
-    """Resource-aware process pool manager for CPU-intensive tasks."""
-
-    def __init__(
-        self,
-        max_processes: int | None = None,
-        memory_limit_gb: float | None = None,
-    ) -> None:
-        """Initialize the process pool manager.
-
-        Args:
-            max_processes: Maximum number of processes. Defaults to CPU count.
-            memory_limit_gb: Memory limit in GB. Defaults to 75% of available memory.
-        """
-        self.max_processes = max_processes or mp.cpu_count()
-
-        if memory_limit_gb is None:
-            available_memory = psutil.virtual_memory().available
-            self.memory_limit_bytes = int(available_memory * 0.75)  # Use 75% of available  # ~keep
-        else:
-            self.memory_limit_bytes = int(memory_limit_gb * 1024**3)
-
-        self._executor: ProcessPoolExecutor | None = None
-        self._active_tasks = 0
-
-    def get_optimal_workers(self, task_memory_mb: float = 100) -> int:
-        """Calculate optimal number of workers based on memory constraints.
-
-        Args:
-            task_memory_mb: Estimated memory usage per task in MB.
-
-        Returns:
-            Optimal number of workers.
-        """
-        task_memory_bytes = task_memory_mb * 1024**2
-        memory_based_limit = max(1, int(self.memory_limit_bytes / task_memory_bytes))
-
-        return min(self.max_processes, memory_based_limit)
-
-    def _ensure_executor(self, max_workers: int | None = None) -> ProcessPoolExecutor:
-        """Ensure process pool executor is initialized."""
-        if self._executor is None or getattr(self._executor, "_max_workers", None) != max_workers:
-            if self._executor is not None:
-                self._executor.shutdown(wait=False)
-
-            workers = max_workers or self.max_processes
-            self._executor = ProcessPoolExecutor(max_workers=workers)
-
-        return self._executor
-
-    async def submit_task(
-        self,
-        func: Callable[..., T],
-        *args: Any,
-        task_memory_mb: float = 100,
-    ) -> T:
-        """Submit a task to the process pool.
-
-        Args:
-            func: Function to execute.
-            *args: Positional arguments for the function.
-            task_memory_mb: Estimated memory usage in MB.
-
-        Returns:
-            Result of the function execution.
-        """
-        workers = self.get_optimal_workers(task_memory_mb)
-        self._ensure_executor(workers)
-
-        self._active_tasks += 1
-
-        try:
-            return await anyio.to_thread.run_sync(func, *args)
-        finally:
-            self._active_tasks -= 1
-
-    async def submit_batch(
-        self,
-        func: Callable[..., T],
-        arg_batches: list[tuple[Any, ...]],
-        task_memory_mb: float = 100,
-        max_concurrent: int | None = None,
-    ) -> list[T]:
-        """Submit a batch of tasks to the process pool.
-
-        Args:
-            func: Function to execute.
-            arg_batches: List of argument tuples for each task.
-            task_memory_mb: Estimated memory usage per task in MB.
-            max_concurrent: Maximum concurrent tasks. Defaults to optimal workers.
-
-        Returns:
-            List of results in the same order as input.
-        """
-        if not arg_batches:
-            return []
-
-        workers = self.get_optimal_workers(task_memory_mb)
-        max_concurrent = max_concurrent or workers
-
-        self._ensure_executor(workers)
-
-        semaphore = anyio.CapacityLimiter(max_concurrent)
-
-        async def submit_single(args: tuple[Any, ...]) -> T:
-            async with semaphore:
-                self._active_tasks += 1
-                try:
-                    return await anyio.to_thread.run_sync(func, *args)
-                finally:
-                    self._active_tasks -= 1
-
-        async with anyio.create_task_group() as tg:
-            results: list[T] = [None] * len(arg_batches)  # type: ignore[list-item]
-
-            async def run_task(idx: int, args: tuple[Any, ...]) -> None:
-                results[idx] = await submit_single(args)
-
-            for idx, args in enumerate(arg_batches):
-                tg.start_soon(run_task, idx, args)
-
-        return results
-
-    def get_system_info(self) -> dict[str, Any]:
-        """Get current system resource information."""
-        memory = psutil.virtual_memory()
-        cpu_percent = psutil.cpu_percent(interval=1)
-
-        return {
-            "cpu_count": mp.cpu_count(),
-            "cpu_percent": cpu_percent,
-            "memory_total": memory.total,
-            "memory_available": memory.available,
-            "memory_percent": memory.percent,
-            "active_tasks": self._active_tasks,
-            "max_processes": self.max_processes,
-            "memory_limit": self.memory_limit_bytes,
-        }
-
-    def shutdown(self, wait: bool = True) -> None:
-        """Shutdown the process pool."""
-        if self._executor is not None:
-            self._executor.shutdown(wait=wait)
-            self._executor = None
-
-    def __enter__(self) -> Self:
-        """Context manager entry."""
-        return self
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: types.TracebackType | None,
-    ) -> None:
-        """Context manager exit."""
-        self.shutdown()
-
-    async def __aenter__(self) -> Self:
-        """Async context manager entry."""
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: types.TracebackType | None,
-    ) -> None:
-        """Async context manager exit."""
-        self.shutdown()