Create app.py

app.py

@@ -0,0 +1,494 @@
+import gradio as gr
+import pdfplumber
+import re
+import requests
+import tempfile
+import os
+from typing import List, Dict, Any
+import html
+
+try:
+    import fitz  # PyMuPDF
+    PYMUPDF_AVAILABLE = True
+except ImportError:
+    PYMUPDF_AVAILABLE = False
+    print("PyMuPDF not available, using pdfplumber only")
+
+from dataclasses import dataclass
+
+
+@dataclass
+class PDFElement:
+    """Represents an element extracted from PDF"""
+    type: str
+    content: Any
+    page: int
+    bbox: tuple = None
+    style: Dict = None
+    level: int = None
+
+
+class PDFProcessor:
+    """Simplified PDF processor"""
+    
+    def __init__(self):
+        self.elements = []
+        self.html_content = ""
+        self.element_counter = 0
+        
+    def process_pdf(self, pdf_url: str) -> Dict:
+        """Process PDF from URL"""
+        temp_file = None
+        
+        try:
+            temp_file = self._download_pdf(pdf_url)
+            
+            # Extract content
+            self.elements = self._extract_content(temp_file)
+            self.html_content = self._convert_to_html()
+            
+            # Get summary
+            summary = {
+                'total_elements': len(self.elements),
+                'pages': max([e.page for e in self.elements]) if self.elements else 0,
+                'headings': len([e for e in self.elements if e.type == 'heading']),
+                'tables': len([e for e in self.elements if e.type == 'table']),
+                'paragraphs': len([e for e in self.elements if e.type == 'paragraph'])
+            }
+            
+            return summary
+            
+        finally:
+            if temp_file and os.path.exists(temp_file):
+                try:
+                    os.unlink(temp_file)
+                except:
+                    pass
+    
+    def _download_pdf(self, url: str) -> str:
+        """Download PDF from URL"""
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+        
+        response = requests.get(url, headers=headers, timeout=30)
+        response.raise_for_status()
+        
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.pdf')
+        temp_file.write(response.content)
+        temp_file.close()
+        
+        return temp_file.name
+    
+    def _get_element_id(self, element_type: str) -> str:
+        """Generate unique ID for element"""
+        self.element_counter += 1
+        return f"{element_type}-{self.element_counter}"
+    
+    def _extract_content(self, pdf_path: str) -> List[PDFElement]:
+        """Extract structured content from PDF"""
+        elements = []
+        
+        if PYMUPDF_AVAILABLE:
+            try:
+                # Try PyMuPDF first for better structure detection
+                doc = fitz.open(pdf_path)
+                
+                for page_num, page in enumerate(doc, 1):
+                    blocks = page.get_text("dict")
+                    
+                    for block in blocks["blocks"]:
+                        if block["type"] == 0:  # Text block
+                            for line in block["lines"]:
+                                for span in line["spans"]:
+                                    text = span["text"].strip()
+                                    if not text:
+                                        continue
+                                    
+                                    font_size = span["size"]
+                                    
+                                    # Simple classification
+                                    if font_size > 14:
+                                        element_type = "heading"
+                                        level = 1 if font_size > 18 else 2
+                                    elif re.match(r'^[\d\-\•\*]+\.?\s+', text):
+                                        element_type = "list"
+                                        level = None
+                                    else:
+                                        element_type = "paragraph"
+                                        level = None
+                                    
+                                    elements.append(PDFElement(
+                                        type=element_type,
+                                        content=text,
+                                        page=page_num,
+                                        level=level
+                                    ))
+                
+                doc.close()
+                
+                # Also get tables with pdfplumber
+                with pdfplumber.open(pdf_path) as pdf:
+                    for page_num, page in enumerate(pdf.pages, 1):
+                        tables = page.extract_tables()
+                        for table in tables:
+                            if table:
+                                elements.append(PDFElement(
+                                    type="table",
+                                    content=table,
+                                    page=page_num
+                                ))
+                
+                return elements
+                
+            except Exception as e:
+                print(f"PyMuPDF failed: {e}, falling back to pdfplumber")
+        
+        # Fallback to pdfplumber only
+        with pdfplumber.open(pdf_path) as pdf:
+            for page_num, page in enumerate(pdf.pages, 1):
+                text = page.extract_text() or ""
+                lines = text.split('\n')
+                
+                for line in lines:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    
+                    if line.isupper() and len(line) < 100:
+                        element_type = "heading"
+                        level = 1
+                    elif re.match(r'^[\d\-\•\*]+\.?\s+', line):
+                        element_type = "list"
+                        level = None
+                    else:
+                        element_type = "paragraph"
+                        level = None
+                    
+                    elements.append(PDFElement(
+                        type=element_type,
+                        content=line,
+                        page=page_num,
+                        level=level
+                    ))
+                
+                # Extract tables
+                tables = page.extract_tables()
+                for table in tables:
+                    if table:
+                        elements.append(PDFElement(
+                            type="table",
+                            content=table,
+                            page=page_num
+                        ))
+        
+        return elements
+    
+    def _convert_to_html(self) -> str:
+        """Convert elements to HTML with IDs and styling"""
+        html_parts = ['''
+<style>
+    .pdf-content {
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+        line-height: 1.8;
+        color: #333;
+        max-width: 100%;
+        padding: 20px;
+    }
+    .pdf-content h1, 
+    .pdf-content h2, 
+    .pdf-content h3 {
+        color: #2c3e50;
+        margin: 25px 0 15px 0;
+        font-weight: 600;
+    }
+    .pdf-content h1 { font-size: 2em; border-bottom: 3px solid #667eea; padding-bottom: 10px; }
+    .pdf-content h2 { font-size: 1.6em; border-bottom: 2px solid #e0e0e0; padding-bottom: 8px; }
+    .pdf-content h3 { font-size: 1.3em; }
+    .pdf-content table {
+        border-collapse: collapse;
+        width: 100%;
+        margin: 20px 0;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+        border-radius: 8px;
+        overflow: hidden;
+    }
+    .pdf-content th, 
+    .pdf-content td {
+        border: 1px solid #e0e0e0;
+        padding: 12px 15px;
+        text-align: left;
+    }
+    .pdf-content th {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        font-weight: 600;
+        text-transform: uppercase;
+        font-size: 0.9em;
+        letter-spacing: 0.5px;
+    }
+    .pdf-content tr:nth-child(even) {
+        background-color: #f8f9fa;
+    }
+    .pdf-content tr:hover {
+        background-color: #e3f2fd;
+        transition: background-color 0.2s;
+    }
+    .pdf-content p {
+        margin: 12px 0;
+        text-align: justify;
+    }
+    .pdf-content li {
+        margin: 8px 0;
+        margin-left: 25px;
+    }
+    .pdf-content .page-marker {
+        color: #666;
+        font-size: 0.95em;
+        font-weight: 600;
+        margin: 40px 0 20px 0;
+        padding: 12px 20px;
+        background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+        border-left: 5px solid #667eea;
+        border-radius: 4px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    .pdf-content ul, .pdf-content ol {
+        margin: 15px 0;
+        padding-left: 30px;
+    }
+</style>
+<div class="pdf-content">
+''']
+        
+        current_page = 0
+        in_list = False
+        
+        for elem in self.elements:
+            # Add page marker
+            if elem.page != current_page:
+                if in_list:
+                    html_parts.append('</ul>')
+                    in_list = False
+                current_page = elem.page
+                html_parts.append(f'<div class="page-marker" id="page-{current_page}">📄 Page {current_page}</div>')
+            
+            if elem.type == "heading":
+                if in_list:
+                    html_parts.append('</ul>')
+                    in_list = False
+                level = elem.level or 2
+                elem_id = self._get_element_id('heading')
+                content = html.escape(elem.content)
+                html_parts.append(f'<h{level} id="{elem_id}" data-page="{elem.page}">{content}</h{level}>')
+            
+            elif elem.type == "paragraph":
+                if in_list:
+                    html_parts.append('</ul>')
+                    in_list = False
+                elem_id = self._get_element_id('paragraph')
+                content = html.escape(elem.content)
+                html_parts.append(f'<p id="{elem_id}" data-page="{elem.page}">{content}</p>')
+            
+            elif elem.type == "list":
+                if not in_list:
+                    html_parts.append('<ul>')
+                    in_list = True
+                elem_id = self._get_element_id('list-item')
+                content = html.escape(elem.content)
+                html_parts.append(f'<li id="{elem_id}" data-page="{elem.page}">{content}</li>')
+            
+            elif elem.type == "table":
+                if in_list:
+                    html_parts.append('</ul>')
+                    in_list = False
+                elem_id = self._get_element_id('table')
+                html_parts.append(f'<table id="{elem_id}" data-page="{elem.page}">')
+                for i, row in enumerate(elem.content):
+                    row_id = self._get_element_id('table-row')
+                    html_parts.append(f'<tr id="{row_id}">')
+                    tag = 'th' if i == 0 else 'td'
+                    for j, cell in enumerate(row):
+                        cell_id = self._get_element_id('table-cell')
+                        cell_content = html.escape(str(cell)) if cell else ""
+                        html_parts.append(f'<{tag} id="{cell_id}">{cell_content}</{tag}>')
+                    html_parts.append('</tr>')
+                html_parts.append('</table>')
+        
+        if in_list:
+            html_parts.append('</ul>')
+        
+        html_parts.append('</div>')
+        return '\n'.join(html_parts)
+
+
+# Global processor
+processor = PDFProcessor()
+
+
+def process_pdf_url(pdf_url):
+    """Process PDF from URL"""
+    global processor
+    
+    if not pdf_url or not pdf_url.strip():
+        return "❌ Please enter a PDF URL", "", ""
+    
+    try:
+        processor = PDFProcessor()
+        summary = processor.process_pdf(pdf_url.strip())
+        
+        summary_text = f"""### ✅ PDF Processed Successfully!
+
+**📊 Summary:**
+- **Total Elements:** {summary['total_elements']}
+- **Pages:** {summary['pages']}
+- **Headings:** {summary['headings']}
+- **Tables:** {summary['tables']}
+- **Paragraphs:** {summary['paragraphs']}
+"""
+        
+        return summary_text, processor.html_content, processor.html_content
+        
+    except Exception as e:
+        error_msg = f"❌ Error processing PDF: {str(e)}"
+        return error_msg, "", ""
+
+
+# Create Gradio interface
+with gr.Blocks(
+    title="PDF to HTML Converter",
+    theme=gr.themes.Soft(
+        primary_hue="indigo",
+        secondary_hue="purple",
+    ),
+    css="""
+        .gradio-container {
+            max-width: 1200px !important;
+        }
+        #html_preview {
+            min-height: 600px;
+            max-height: 800px;
+            overflow-y: auto;
+            border: 1px solid #e0e0e0;
+            border-radius: 8px;
+            padding: 20px;
+            background: white;
+        }
+        #html_source {
+            font-family: 'Courier New', monospace;
+            font-size: 13px;
+            line-height: 1.5;
+        }
+    """
+) as demo:
+    
+    gr.Markdown(
+        """
+        # 📄 PDF to HTML Converter
+        
+        Extract PDF content and view as beautifully structured HTML with unique IDs for each element.
+        
+        Simply paste a PDF URL and click **Process PDF** to get started!
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=4):
+            pdf_url_input = gr.Textbox(
+                label="PDF URL",
+                placeholder="https://example.com/document.pdf",
+                lines=1,
+                max_lines=1
+            )
+        with gr.Column(scale=1):
+            process_btn = gr.Button(
+                "🚀 Process PDF",
+                variant="primary",
+                size="lg"
+            )
+    
+    summary_output = gr.Markdown(label="Summary")
+    
+    gr.Markdown("---")
+    
+    with gr.Tabs():
+        with gr.Tab("📋 HTML Preview"):
+            html_preview = gr.HTML(
+                label="Rendered HTML",
+                elem_id="html_preview"
+            )
+        
+        with gr.Tab("💻 HTML Source"):
+            html_source = gr.Code(
+                label="HTML Source Code",
+                language="html",
+                lines=25,
+                elem_id="html_source"
+            )
+            download_btn = gr.Button("📥 Download HTML", variant="secondary")
+            download_file = gr.File(label="Download", visible=False)
+    
+    # Event handlers
+    process_btn.click(
+        fn=process_pdf_url,
+        inputs=[pdf_url_input],
+        outputs=[summary_output, html_preview, html_source]
+    )
+    
+    # Allow Enter key to process
+    pdf_url_input.submit(
+        fn=process_pdf_url,
+        inputs=[pdf_url_input],
+        outputs=[summary_output, html_preview, html_source]
+    )
+    
+    def create_download_file(html_content):
+        if not html_content:
+            return None
+        
+        # Create full HTML document
+        full_html = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Extracted PDF Content</title>
+</head>
+<body>
+{html_content}
+</body>
+</html>"""
+        
+        temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.html', encoding='utf-8')
+        temp_file.write(full_html)
+        temp_file.close()
+        return temp_file.name
+    
+    download_btn.click(
+        fn=create_download_file,
+        inputs=[html_source],
+        outputs=[download_file]
+    )
+    
+    gr.Markdown(
+        """
+        ---
+        ### 📌 Features:
+        - ✨ Extracts text, tables, headings from PDFs
+        - 🎯 Each HTML element has a unique ID
+        - 📊 Beautiful table styling
+        - 🔖 Page markers for easy navigation
+        - 💾 Download extracted HTML
+        
+        ### 💡 Example PDFs to try:
+        - Research papers from arXiv
+        - Product documentation
+        - Financial reports
+        - Any publicly accessible PDF!
+        """
+    )
+
+
+# Launch
+if __name__ == "__main__":
+    demo.launch()