pdf2epub 0.1.2 → 0.1.3

package/vendor/pdf2epub/modules/pdf2md.py

@@ -1,172 +0,0 @@
-from pathlib import Path
-import sys
-import json
-from PIL import Image
-import io
-
-def get_default_output_dir(input_path: Path) -> Path:
-    """
-    Generate default output directory path based on input PDF path.
-    Creates a directory with same name as PDF (without extension) next to the PDF.
-    """
-    return input_path.parent / input_path.stem
-
-def get_default_input_dir() -> Path:
-    """
-    Get default input directory (./input) relative to current working directory.
-    Creates it if it doesn't exist.
-    """
-    input_dir = Path.cwd() / 'input'
-    input_dir.mkdir(exist_ok=True)
-    return input_dir
-
-
-def save_images(images: dict, image_dir: Path) -> None:
-    """
-    Save images with proper error handling and format detection.
-    Preserves original image filenames from the input.
-    
-    Args:
-        images: Dictionary of images from marker-pdf conversion where keys are filenames
-        image_dir: Directory to save images to
-    """
-    if not images:
-        print("No images found in document")
-        return
-        
-    image_dir.mkdir(exist_ok=True)
-    saved_count = 0
-    
-    for filename, image_data in images.items():
-        try:
-            # Skip if image data is None or empty
-            if not image_data:
-                continue
-                
-            image_path = image_dir / filename
-            
-            # Handle different image data formats
-            if isinstance(image_data, Image.Image):
-                image_data.save(image_path)
-                saved_count += 1
-                    
-            elif isinstance(image_data, bytes):
-                img = Image.open(io.BytesIO(image_data))
-                img.save(image_path)
-                saved_count += 1
-                    
-            elif isinstance(image_data, str):
-                if Path(image_data).exists():
-                    img = Image.open(image_data)
-                    img.save(image_path)
-                    saved_count += 1
-                else:
-                    print(f"Image path does not exist: {image_data}")
-            else:
-                print(f"Unsupported image data type for {filename}: {type(image_data)}")
-                
-        except Exception as e:
-            print(f"Error saving image {filename}: {str(e)}")
-            continue
-            
-    if saved_count > 0:
-        print(f"Successfully saved {saved_count} images to: {image_dir}")
-    else:
-        print("No valid images were found to save")
-
-def convert_pdf(
-    input_path: str,
-    output_dir: Path,
-    max_pages: int = None,
-    start_page: int = None,
-) -> None:
-    """
-    Convert a single PDF file to markdown format with enhanced image handling.
-    """
-    try:
-        from marker.models import create_model_dict
-        from marker.converters.pdf import PdfConverter
-
-        models = create_model_dict()
-
-        # Build page_range config. marker-pdf 1.x requires an explicit list of
-        # page indices; there is no "start to end" shorthand. If start_page is
-        # given without max_pages we cannot construct the range without knowing
-        # the document's page count, so we warn and process all pages instead.
-        config = {}
-        if max_pages is not None:
-            s = start_page or 0
-            config["page_range"] = list(range(s, s + max_pages))
-        elif start_page is not None:
-            print(
-                "Warning: --start-page requires --max-pages in marker-pdf 1.x "
-                "(no open-ended page range is supported). Processing all pages."
-            )
-
-        converter = PdfConverter(config=config, artifact_dict=models)
-        rendered = converter(input_path)
-
-        full_text = rendered.markdown
-        images = rendered.images
-        metadata = rendered.metadata
-
-        # All output will go to the output directory
-        output_dir.mkdir(parents=True, exist_ok=True)
-
-        # Save markdown content
-        md_output = output_dir / f"{Path(input_path).stem}.md"
-        md_output.write_text(full_text, encoding='utf-8')
-        print(f"Markdown saved to: {md_output}")
-
-        # Save metadata as JSON
-        meta_output = output_dir / f"{Path(input_path).stem}_metadata.json"
-        with open(meta_output, 'w', encoding='utf-8') as f:
-            json.dump(metadata, f, indent=2)
-        print(f"Metadata saved to: {meta_output}")
-
-        # Enhanced image handling
-        try:
-            if images:
-                image_dir = output_dir / "images"
-                save_images(images, image_dir)
-
-                # Cleanup PIL Images
-                for img in images.values():
-                    if isinstance(img, Image.Image):
-                        try:
-                            img.close()
-                        except Exception as e:
-                            print(f"Warning: Failed to close image: {e}")
-                images.clear()
-        except Exception as e:
-            print(f"Warning: Error during image cleanup: {e}")
-
-    except Exception as e:
-        print(f"Error converting {input_path}: {str(e)}", file=sys.stderr)
-        raise
-
-    
-def add_pdfs_to_queue(input_path: Path) -> list[Path]:
-    """
-    Add PDF files to the processing queue.
-    If input_path is a directory, add all PDFs in it.
-    If input_path is a file, add just that file.
-    """
-    queue = []
-    
-    if input_path.is_dir():
-        pdfs = list(input_path.glob('*.pdf'))
-        if not pdfs:
-            print(f"No PDF files found in directory: {input_path}", file=sys.stderr)
-            sys.exit(1)
-        queue.extend(pdfs)
-    else:
-        if not input_path.is_file():
-            print(f"Error: Input file does not exist: {input_path}", file=sys.stderr)
-            sys.exit(1)
-        if input_path.suffix.lower() != '.pdf':
-            print(f"Error: Input file must be a PDF: {input_path}", file=sys.stderr)
-            sys.exit(1)
-        queue.append(input_path)
-        
-    return queue

package/vendor/pdf2epub/modules/postprocessing/prompt.txt

@@ -1,41 +0,0 @@
-You are a specialized pattern recognition system for markdown documents generated from PDF conversions. Your task is to analyze the following markdown content for common error patterns that typically occur during PDF-to-markdown conversion, while adhering to these strict requirements:
-
-1. DO NOT alter any markdown formatting syntax
-2. DO NOT modify any actual content
-3. DO NOT suggest changes to filenames or file structure
-4. ONLY identify patterns that represent clear conversion errors
-
-Analyze the markdown for patterns such as:
-- Incorrectly joined words (e.g., "helloworld" instead of "hello world")
-- Misplaced line breaks that split sentences inappropriately
-- Repeated punctuation marks or whitespace
-- Common OCR artifacts (e.g., "rn" being recognized as "m")
-- Inconsistent list item formatting
-- Table formatting inconsistencies
-- Code block formatting issues
-- Image reference errors
-- Header hierarchy inconsistencies
-- Footnote formatting issues
-
-PROVIDE YOUR RESPONSE ONLY AS A JSON OBJECT WITH THIS STRUCTURE:
-{
-    "patterns": [
-        {
-            "pattern_id": "unique_identifier",
-            "description": "Brief description of the error pattern",
-            "regex": "regex_pattern_to_match_error",
-            "severity": "high|medium|low",
-            "category": "formatting|ocr|structure|whitespace|other",
-            "example": "Example of the pattern from the text"
-        }
-    ]
-}
-
-The regex patterns must:
-1. Use Python regex syntax
-2. Include word boundaries where appropriate
-3. Be as specific as possible to avoid false positives
-4. Account for possible variations in the pattern
-5. Be tested against the provided content
-
-DO NOT include any explanatory text or additional information outside the JSON structure.

package/vendor/pdf2epub/modules/postprocessing/template.py

@@ -1,177 +0,0 @@
-#!/usr/bin/env python3
-"""
-PDF2EPUB Markdown Postprocessing Template
-
-This template is used to analyze markdown content and generate a customized
-postprocessing script that fixes common error patterns while preserving
-markdown formatting and content integrity.
-
-Instructions for AI:
-1. Analyze the provided markdown section for common error patterns
-2. Define regex patterns to identify these errors
-3. Provide safe replacement patterns that preserve markdown formatting
-4. Return a complete script with the patterns and fixes
-
-IMPORTANT:
-- Do not modify actual content or meaning
-- Preserve all markdown formatting
-- Ensure filename and location remain unchanged
-- Validate all regex patterns before replacing
-- Use non-destructive transformations only
-
-Send ONLY the python script content back to the user. your answer should exclusively contain the script which can be directly run by the user and have the input filename and the output filename with the appropriate absolute path hard-coded.
-"""
-
-import re
-from pathlib import Path
-from typing import List
-import logging
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-class MarkdownFix:
-    """Represents a specific markdown formatting fix with its regex pattern."""
-    def __init__(self, name: str, pattern: str, replacement: str, description: str):
-        self.name = name
-        self.pattern = pattern
-        self.replacement = replacement
-        self.description = description
-        
-    def apply(self, content: str) -> str:
-        """Apply the fix while preserving markdown formatting."""
-        try:
-            # Compile regex pattern
-            regex = re.compile(self.pattern, re.MULTILINE | re.DOTALL)
-            
-            # Count matches before replacement
-            matches = len(regex.findall(content))
-            
-            # Apply fix
-            new_content = regex.sub(self.replacement, content)
-            
-            # Log the changes
-            if matches > 0:
-                logger.info(f"Applied fix '{self.name}': {matches} matches found and processed")
-            
-            return new_content
-            
-        except re.error as e:
-            logger.error(f"Regex error in fix '{self.name}': {str(e)}")
-            return content
-        except Exception as e:
-            logger.error(f"Error applying fix '{self.name}': {str(e)}")
-            return content
-
-class MarkdownPostprocessor:
-    """Handles the postprocessing of markdown files."""
-    
-    def __init__(self):
-        self.fixes: List[MarkdownFix] = []
-        
-    def add_fix(self, fix: MarkdownFix) -> None:
-        """Add a new fix to the processor."""
-        self.fixes.append(fix)
-        
-    def validate_content(self, content: str) -> bool:
-        """
-        Validate that the content still contains essential markdown elements
-        after processing.
-        """
-        # Check for common markdown structures that should be preserved
-        essential_patterns = [
-            (r'^#+ .*$', 'headers'),               # Headers
-            (r'^\* .*$', 'bullet points'),         # Bullet points
-            (r'^\d+\. .*$', 'numbered lists'),     # Numbered lists
-            (r'`[^`]+`', 'inline code'),           # Inline code
-            (r'^\s*```.*?```', 'code blocks'),     # Code blocks
-            (r'!\[.*?\]\(.*?\)', 'images'),        # Images
-            (r'\[.*?\]\(.*?\)', 'links'),          # Links
-            (r'\*\*.*?\*\*', 'bold text'),         # Bold text
-            (r'_.*?_', 'italic text'),             # Italic text
-            (r'\|.*?\|', 'tables'),                # Tables
-        ]
-        
-        # Store counts before processing
-        initial_counts = {
-            name: len(re.findall(pattern, content, re.MULTILINE | re.DOTALL))
-            for pattern, name in essential_patterns
-        }
-        
-        return initial_counts
-        
-    def process_file(self, filepath: Path) -> bool:
-        """
-        Process a markdown file while preserving its formatting and content.
-        Returns True if processing was successful.
-        """
-        try:
-            # Read original content
-            original_content = filepath.read_text(encoding='utf-8')
-            
-            # Validate initial content
-            initial_counts = self.validate_content(original_content)
-            
-            # Create temporary content for processing
-            processed_content = original_content
-            
-            # Apply each fix sequentially
-            for fix in self.fixes:
-                processed_content = fix.apply(processed_content)
-            
-            # Validate processed content
-            final_counts = self.validate_content(processed_content)
-            
-            # Compare markdown element counts
-            for element, initial_count in initial_counts.items():
-                final_count = final_counts[element]
-                if final_count < initial_count:
-                    logger.warning(
-                        f"Warning: Number of {element} decreased from "
-                        f"{initial_count} to {final_count}"
-                    )
-            
-            # Write processed content back to the same file
-            filepath.write_text(processed_content, encoding='utf-8')
-            
-            logger.info(f"Successfully processed: {filepath}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Error processing {filepath}: {str(e)}")
-            return False
-
-def main():
-    """
-    AI INSTRUCTIONS:
-    Replace this function with specific fixes for the analyzed markdown content.
-    Include regex patterns and replacements that address identified issues.
-    """
-    processor = MarkdownPostprocessor()
-    
-    # Example fixes (AI should replace these with document-specific fixes):
-    processor.add_fix(MarkdownFix(
-        name="fix_excessive_newlines",
-        pattern=r"\n{3,}",
-        replacement="\n\n",
-        description="Replace excessive newlines with double newlines"
-    ))
-    
-    # Add more fixes here based on analysis...
-    
-    return processor
-
-if __name__ == "__main__":
-    # Get processor with document-specific fixes
-    processor = main()
-    
-    # Process the markdown file
-    input_file = Path("input.md")  # AI should use actual filename
-    if processor.process_file(input_file):
-        logger.info("Postprocessing completed successfully")
-    else:
-        logger.error("Postprocessing failed")

package/vendor/pdf2epub/requirements.txt

@@ -1,8 +0,0 @@
-# Python 3.13 is recommended.
-# marker-pdf constrains Pillow<11.0.0, and Pillow only ships cp314 wheels from
-# 11.3.0 onward, so on Python 3.14 pip builds Pillow from source rather than
-# installing a wheel.
-marker-pdf==1.10.2
-transformers==4.57.6
-markdown==3.10.2
-latex2mathml==3.81.0