pdf2epub 0.1.0

package/vendor/pdf2epub/README.md

@@ -0,0 +1,217 @@
+# PDF2EPUB 📚
+
+Convert PDF files to nicely structured Markdown and EPUB format with intelligent layout detection.
+
+## ✨ Features
+
+- 📖 Smart layout detection for books and academic papers
+- 🔍 Advanced text extraction and OCR capabilities
+- 📊 Table detection and formatting
+- 🖼️ Image extraction and optimization
+- 📝 Clean markdown output with preserved structure
+- 📱 EPUB generation with customizable styling
+- 🌍 Multi-language support
+- 🚀 GPU acceleration support (NVIDIA & AMD)
+- 🍎 Apple Silicon support
+
+## 🛠️ Dependencies
+
+- Python 3.10–3.14 (3.13 recommended, see below)
+- PyTorch (with CUDA/ROCm support for GPU acceleration)
+- marker-pdf==1.10.2
+- transformers==4.57.6
+- markdown==3.10.2
+- latex2mathml==3.81.0
+
+### ⚠️ Python version
+
+Python 3.13 is recommended.
+
+`marker-pdf` constrains `Pillow<11.0.0`, and Pillow only ships Python 3.14
+wheels from 11.3.0 onward. On Python 3.10–3.13 every dependency installs as a
+prebuilt wheel. On 3.14, pip has to build Pillow from source instead: this
+works, but it is slower and requires a working C toolchain plus the image
+library headers Pillow links against. On Debian/Ubuntu install them first:
+
+```bash
+sudo apt install libjpeg-dev zlib1g-dev libtiff-dev libfreetype6-dev libwebp-dev
+```
+
+Without these headers the install fails with
+`RequiredDependencyException: The headers or library files could not be found for jpeg`.
+
+## 💻 Installation
+
+1. Create and activate a virtual environment.
+
+On Linux/Mac:
+```bash
+python3.13 -m venv .venv
+source .venv/bin/activate
+```
+
+On Windows:
+```powershell
+py -3.13 -m venv .venv
+.venv\Scripts\activate
+```
+
+2. Install Python dependencies (this installs PyTorch as well):
+```bash
+pip install -r requirements.txt
+```
+
+3. GPU acceleration (optional):
+
+PyTorch is installed as a dependency in step 2. On Apple Silicon that wheel
+already supports MPS, so no further action is needed. For a specific CUDA or
+ROCm build, reinstall PyTorch using the selector at
+[pytorch.org/get-started/locally](https://pytorch.org/get-started/locally/).
+For example, for AMD GPUs with ROCm:
+```bash
+pip uninstall torch torchvision torchaudio
+pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.2
+```
+
+4. Verify GPU support:
+```python
+import torch
+print(torch.__version__)  # PyTorch version
+print(torch.cuda.is_available())  # Should return True for NVIDIA
+print(torch.backends.mps.is_available())  # Should return True for Apple Silicon
+print(torch.version.hip)  # Should print ROCm version for AMD
+```
+
+### 🐳 Docker
+
+A CPU-only image can be built from the included `Dockerfile`:
+
+```bash
+docker build -t pdf2epub .
+```
+
+Run it with your PDFs mounted at `/data` and a model cache volume (marker-pdf
+downloads its models on first run):
+
+```bash
+docker run -it --rm \
+  -v "$(pwd)":/data \
+  -v pdf2epub-models:/models \
+  pdf2epub input.pdf
+```
+
+`-it` is required for EPUB generation because metadata is prompted
+interactively; with `--skip-epub` it can run non-interactively.
+
+Tagged releases are also published to
+`ghcr.io/overcuriousity/pdf2epub` by the Docker workflow.
+
+## 🚀 Usage
+
+### Basic Usage
+
+Convert a single PDF file:
+```bash
+python main.py input.pdf
+```
+
+Convert all PDFs in a directory:
+```bash
+python main.py input_directory/
+```
+
+EPUB generation prompts interactively for metadata (title, author, language,
+and so on; press Enter to accept each default). It therefore needs a terminal —
+run it non-interactively and it will fail with `EOFError`. Use `--skip-epub` to
+produce only markdown without any prompts.
+
+### Advanced Options
+
+```bash
+python main.py [input_path] [output_path] [options]
+
+Options:
+  --max-pages INT          Maximum number of pages to process
+  --start-page INT         Page number to start from
+  --skip-epub              Skip EPUB generation, only create markdown
+  --skip-md                Skip markdown generation, use existing markdown files
+```
+
+If `input_path` is omitted, all PDFs in `./input/` are processed.
+
+### Examples
+
+Process a specific range of pages:
+```bash
+python main.py book.pdf --start-page 10 --max-pages 50
+```
+
+Convert to markdown only:
+```bash
+python main.py thesis.pdf --skip-epub
+```
+
+### Output Structure
+
+```
+output_directory/
+├── document_name/
+│   ├── document_name.md
+│   ├── document_name.epub
+│   ├── document_name_metadata.json
+│   └── images/
+│       ├── image1.png
+│       ├── image2.jpg
+│       └── ...
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Here's how you can help:
+
+1. Fork the repository
+2. Create a new branch for your feature
+3. Commit your changes
+4. Push to your branch
+5. Create a Pull Request
+
+Please ensure your code follows the existing style and includes appropriate tests.
+
+### Development Setup
+
+1. Clone the repository:
+```bash
+git clone https://github.com/overcuriousity/pdf2epub.git
+cd pdf2epub
+```
+
+2. Create a virtual environment:
+```bash
+python -m venv venv
+source venv/bin/activate  # Linux/Mac
+venv\Scripts\activate     # Windows
+```
+
+3. Install development dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🐛 Known Issues
+
+- Some image embedding might need manual adjustment
+- Some complex mathematical equations might not be perfectly converted
+- Certain PDF layouts with multiple columns may require manual adjustment
+- Font detection might be imperfect in some cases
+
+## 🙏 Acknowledgments
+
+This project builds upon several excellent open-source libraries:
+- [marker-pdf](https://github.com/VikParuchuri/marker) for PDF processing
+- [mark2epub](https://github.com/AlexPof/mark2epub) for markdown conversion
+- [PyTorch](https://pytorch.org/) for GPU acceleration
+- [Transformers](https://huggingface.co/transformers) for advanced text processing

package/vendor/pdf2epub/UPSTREAM.json

@@ -0,0 +1,8 @@
+{
+  "repo": "overcuriousity/pdf2epub",
+  "ref": "v1.1.0",
+  "commit": "5eae669d1c897b4735f369fb2ff4086237db3a81",
+  "commitDate": "2026-07-16T18:17:11Z",
+  "url": "https://github.com/overcuriousity/pdf2epub/tree/5eae669d1c897b4735f369fb2ff4086237db3a81",
+  "syncedAt": "2026-09-07T09:36:39.940Z"
+}

package/vendor/pdf2epub/main.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+import argparse
+import sys
+from pathlib import Path
+import modules.pdf2md as pdf2md
+import modules.mark2epub as mark2epub
+import torch
+                
+
+
+def main():
+    if torch.cuda.is_available():
+        print("CUDA is available. Using GPU for processing.")
+    elif torch.backends.mps.is_available():
+        print("MPS is available. Using Apple Silicon for processing.")
+    else:
+        print("CUDA is not available. Using CPU for processing.")
+        
+    parser = argparse.ArgumentParser(
+        description='Convert PDF files to EPUB format via Markdown'
+    )
+    parser.add_argument(
+        'input_path',
+        nargs='?',
+        type=str,
+        help='Path to input PDF file or directory (default: ./input/*.pdf)'
+    )
+    parser.add_argument(
+        'output_path',
+        nargs='?',
+        type=str,
+        help='Path to output directory (default: directory named after PDF)'
+    )
+    parser.add_argument(
+        '--max-pages',
+        type=int,
+        default=None,
+        help='Maximum number of pages to process'
+    )
+    parser.add_argument(
+        '--start-page',
+        type=int,
+        default=None,
+        help='Page number to start from'
+    )
+    parser.add_argument(
+        '--skip-epub',
+        action='store_true',
+        help='Skip EPUB generation, only create markdown'
+    )
+    parser.add_argument(
+        '--skip-md',
+        action='store_true',
+        help='Skip markdown generation, use existing markdown files'
+    )
+    
+    args = parser.parse_args()
+    
+    # Get input path
+    input_path = Path(args.input_path) if args.input_path else pdf2md.get_default_input_dir()
+    
+    # Get queue of PDFs to process
+    queue = pdf2md.add_pdfs_to_queue(input_path)
+    print(f"Found {len(queue)} PDF files to process")
+    
+    # Process each PDF
+    failed = []
+    for pdf_path in queue:
+        print(f"\nProcessing: {pdf_path.name}")
+        
+        # Get output directory for this PDF
+        if args.output_path:
+            output_path = Path(args.output_path)
+            markdown_dir = output_path / pdf_path.stem
+        else:
+            markdown_dir = pdf2md.get_default_output_dir(pdf_path)
+            output_path = markdown_dir.parent
+            
+        try:
+            # Check if markdown directory exists when skipping MD generation
+            if args.skip_md:
+                if not markdown_dir.exists():
+                    print(f"Error: Markdown directory not found: {markdown_dir}", file=sys.stderr)
+                    failed.append(pdf_path.name)
+                    continue
+                print(f"Using existing markdown files from: {markdown_dir}")
+                
+            # Convert PDF to Markdown unless skipped
+            if not args.skip_md:
+                print("Converting PDF to Markdown...")
+                pdf2md.convert_pdf(
+                    str(pdf_path),
+                    markdown_dir,
+                    args.max_pages,
+                    args.start_page,
+                )
+            
+            # Convert Markdown to EPUB unless skipped
+            if not args.skip_epub:
+                print("Converting Markdown to EPUB...")
+                mark2epub.convert_to_epub(markdown_dir, output_path)
+                
+        except Exception as e:
+            print(f"Error processing {pdf_path.name}: {str(e)}", file=sys.stderr)
+            failed.append(pdf_path.name)
+            continue
+
+    if failed:
+        print(
+            f"\nFailed to process {len(failed)} of {len(queue)} PDF file(s):",
+            file=sys.stderr,
+        )
+        for name in failed:
+            print(f"  - {name}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()