Rename src/api_app.py to api.py

api.py

@@ -0,0 +1,385 @@
+from fastapi import FastAPI, File, UploadFile, Form, HTTPException
+from fastapi.responses import Response, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import tempfile
+import shutil
+import os
+import subprocess
+import base64
+from pathlib import Path
+
+app = FastAPI(
+    title="HTML to PDF API",
+    description="Convert HTML to PDF using Puppeteer",
+    version="1.0.0"
+)
+
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+def convert_html_to_pdf(html_content: str, aspect_ratio: str):
+    """Convert HTML content to PDF"""
+    temp_dir = None
+    try:
+        temp_dir = tempfile.mkdtemp()
+        
+        # Style injection for better PDF rendering
+        style_injection = """
+        <style>
+            @page { margin: 0; }
+            * {
+                -webkit-print-color-adjust: exact !important;
+                print-color-adjust: exact !important;
+                color-adjust: exact !important;
+            }
+            body {
+                -webkit-print-color-adjust: exact !important;
+                print-color-adjust: exact !important;
+            }
+        </style>
+        """
+        
+        if '</head>' in html_content:
+            html_content = html_content.replace('</head>', style_injection + '</head>')
+        elif '<body' in html_content:
+            html_content = html_content.replace('<body', style_injection + '<body', 1)
+        else:
+            html_content = style_injection + html_content
+        
+        # Save HTML to temp file
+        html_file = os.path.join(temp_dir, "input.html")
+        with open(html_file, 'w', encoding='utf-8') as f:
+            f.write(html_content)
+        
+        # Get puppeteer script path
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        puppeteer_script = os.path.join(script_dir, 'puppeteer_pdf.js')
+        
+        # Run conversion
+        result = subprocess.run(
+            ['node', puppeteer_script, html_file, aspect_ratio],
+            capture_output=True,
+            text=True,
+            timeout=60,
+            cwd=script_dir
+        )
+        
+        if result.returncode != 0:
+            raise Exception(f"PDF conversion failed: {result.stderr}")
+        
+        pdf_file = html_file.replace('.html', '.pdf')
+        
+        if not os.path.exists(pdf_file):
+            raise Exception("PDF file was not generated")
+        
+        with open(pdf_file, 'rb') as f:
+            pdf_bytes = f.read()
+        
+        shutil.rmtree(temp_dir, ignore_errors=True)
+        return pdf_bytes
+        
+    except Exception as e:
+        if temp_dir:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+        raise e
+
+@app.get("/")
+async def root():
+    """API root endpoint"""
+    return {
+        "message": "HTML to PDF Conversion API",
+        "version": "1.0.0",
+        "endpoints": {
+            "POST /convert": "Convert HTML to PDF (file upload)",
+            "POST /convert-text": "Convert HTML text to PDF",
+            "GET /health": "Health check"
+        }
+    }
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "service": "html-to-pdf-api"}
+
+@app.post("/convert")
+async def convert_file(
+    file: UploadFile = File(...),
+    aspect_ratio: str = Form(default="9:16")
+):
+    """
+    Convert uploaded HTML file to PDF
+    
+    - **file**: HTML file to convert
+    - **aspect_ratio**: Page orientation (16:9, 1:1, or 9:16)
+    """
+    if not file.filename.lower().endswith(('.html', '.htm')):
+        raise HTTPException(status_code=400, detail="File must be HTML (.html or .htm)")
+    
+    if aspect_ratio not in ["16:9", "1:1", "9:16"]:
+        raise HTTPException(status_code=400, detail="Invalid aspect ratio. Use: 16:9, 1:1, or 9:16")
+    
+    try:
+        # Read HTML content
+        content = await file.read()
+        try:
+            html_content = content.decode('utf-8')
+        except UnicodeDecodeError:
+            html_content = content.decode('latin-1')
+        
+        # Convert to PDF
+        pdf_bytes = convert_html_to_pdf(html_content, aspect_ratio)
+        
+        # Return PDF file
+        return Response(
+            content=pdf_bytes,
+            media_type="application/pdf",
+            headers={
+                "Content-Disposition": f"attachment; filename={file.filename.replace('.html', '.pdf').replace('.htm', '.pdf')}"
+            }
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Conversion failed: {str(e)}")
+
+@app.post("/convert-text")
+async def convert_text(
+    html: str = Form(...),
+    aspect_ratio: str = Form(default="9:16"),
+    return_base64: bool = Form(default=False)
+):
+    """
+    Convert HTML text to PDF
+    
+    - **html**: HTML content as string
+    - **aspect_ratio**: Page orientation (16:9, 1:1, or 9:16)
+    - **return_base64**: If true, returns base64 encoded PDF in JSON
+    """
+    if aspect_ratio not in ["16:9", "1:1", "9:16"]:
+        raise HTTPException(status_code=400, detail="Invalid aspect ratio. Use: 16:9, 1:1, or 9:16")
+    
+    try:
+        # Convert to PDF
+        pdf_bytes = convert_html_to_pdf(html, aspect_ratio)
+        
+        if return_base64:
+            # Return as JSON with base64 encoded PDF
+            pdf_base64 = base64.b64encode(pdf_bytes).decode('utf-8')
+            return JSONResponse(content={
+                "success": True,
+                "pdf_base64": pdf_base64,
+                "size_bytes": len(pdf_bytes)
+            })
+        else:
+            # Return PDF file directly
+            return Response(
+                content=pdf_bytes,
+                media_type="application/pdf",
+                headers={
+                    "Content-Disposition": "attachment; filename=converted.pdf"
+                }
+            )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Conversion failed: {str(e)}")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)from fastapi import FastAPI, File, UploadFile, Form, HTTPException
+from fastapi.responses import Response, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import tempfile
+import shutil
+import os
+import subprocess
+import base64
+from pathlib import Path
+
+app = FastAPI(
+    title="HTML to PDF API",
+    description="Convert HTML to PDF using Puppeteer",
+    version="1.0.0"
+)
+
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+def convert_html_to_pdf(html_content: str, aspect_ratio: str):
+    """Convert HTML content to PDF"""
+    temp_dir = None
+    try:
+        temp_dir = tempfile.mkdtemp()
+        
+        # Style injection for better PDF rendering
+        style_injection = """
+        <style>
+            @page { margin: 0; }
+            * {
+                -webkit-print-color-adjust: exact !important;
+                print-color-adjust: exact !important;
+                color-adjust: exact !important;
+            }
+            body {
+                -webkit-print-color-adjust: exact !important;
+                print-color-adjust: exact !important;
+            }
+        </style>
+        """
+        
+        if '</head>' in html_content:
+            html_content = html_content.replace('</head>', style_injection + '</head>')
+        elif '<body' in html_content:
+            html_content = html_content.replace('<body', style_injection + '<body', 1)
+        else:
+            html_content = style_injection + html_content
+        
+        # Save HTML to temp file
+        html_file = os.path.join(temp_dir, "input.html")
+        with open(html_file, 'w', encoding='utf-8') as f:
+            f.write(html_content)
+        
+        # Get puppeteer script path
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        puppeteer_script = os.path.join(script_dir, 'puppeteer_pdf.js')
+        
+        # Run conversion
+        result = subprocess.run(
+            ['node', puppeteer_script, html_file, aspect_ratio],
+            capture_output=True,
+            text=True,
+            timeout=60,
+            cwd=script_dir
+        )
+        
+        if result.returncode != 0:
+            raise Exception(f"PDF conversion failed: {result.stderr}")
+        
+        pdf_file = html_file.replace('.html', '.pdf')
+        
+        if not os.path.exists(pdf_file):
+            raise Exception("PDF file was not generated")
+        
+        with open(pdf_file, 'rb') as f:
+            pdf_bytes = f.read()
+        
+        shutil.rmtree(temp_dir, ignore_errors=True)
+        return pdf_bytes
+        
+    except Exception as e:
+        if temp_dir:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+        raise e
+
+@app.get("/")
+async def root():
+    """API root endpoint"""
+    return {
+        "message": "HTML to PDF Conversion API",
+        "version": "1.0.0",
+        "endpoints": {
+            "POST /convert": "Convert HTML to PDF (file upload)",
+            "POST /convert-text": "Convert HTML text to PDF",
+            "GET /health": "Health check"
+        }
+    }
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "service": "html-to-pdf-api"}
+
+@app.post("/convert")
+async def convert_file(
+    file: UploadFile = File(...),
+    aspect_ratio: str = Form(default="9:16")
+):
+    """
+    Convert uploaded HTML file to PDF
+    
+    - **file**: HTML file to convert
+    - **aspect_ratio**: Page orientation (16:9, 1:1, or 9:16)
+    """
+    if not file.filename.lower().endswith(('.html', '.htm')):
+        raise HTTPException(status_code=400, detail="File must be HTML (.html or .htm)")
+    
+    if aspect_ratio not in ["16:9", "1:1", "9:16"]:
+        raise HTTPException(status_code=400, detail="Invalid aspect ratio. Use: 16:9, 1:1, or 9:16")
+    
+    try:
+        # Read HTML content
+        content = await file.read()
+        try:
+            html_content = content.decode('utf-8')
+        except UnicodeDecodeError:
+            html_content = content.decode('latin-1')
+        
+        # Convert to PDF
+        pdf_bytes = convert_html_to_pdf(html_content, aspect_ratio)
+        
+        # Return PDF file
+        return Response(
+            content=pdf_bytes,
+            media_type="application/pdf",
+            headers={
+                "Content-Disposition": f"attachment; filename={file.filename.replace('.html', '.pdf').replace('.htm', '.pdf')}"
+            }
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Conversion failed: {str(e)}")
+
+@app.post("/convert-text")
+async def convert_text(
+    html: str = Form(...),
+    aspect_ratio: str = Form(default="9:16"),
+    return_base64: bool = Form(default=False)
+):
+    """
+    Convert HTML text to PDF
+    
+    - **html**: HTML content as string
+    - **aspect_ratio**: Page orientation (16:9, 1:1, or 9:16)
+    - **return_base64**: If true, returns base64 encoded PDF in JSON
+    """
+    if aspect_ratio not in ["16:9", "1:1", "9:16"]:
+        raise HTTPException(status_code=400, detail="Invalid aspect ratio. Use: 16:9, 1:1, or 9:16")
+    
+    try:
+        # Convert to PDF
+        pdf_bytes = convert_html_to_pdf(html, aspect_ratio)
+        
+        if return_base64:
+            # Return as JSON with base64 encoded PDF
+            pdf_base64 = base64.b64encode(pdf_bytes).decode('utf-8')
+            return JSONResponse(content={
+                "success": True,
+                "pdf_base64": pdf_base64,
+                "size_bytes": len(pdf_bytes)
+            })
+        else:
+            # Return PDF file directly
+            return Response(
+                content=pdf_bytes,
+                media_type="application/pdf",
+                headers={
+                    "Content-Disposition": "attachment; filename=converted.pdf"
+                }
+            )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Conversion failed: {str(e)}")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

src/api_app.py

@@ -1,558 +0,0 @@
-import streamlit as st
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import Response
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from typing import Optional
-import subprocess
-import os
-import tempfile
-import shutil
-import base64
-import re
-import uvicorn
-from threading import Thread
-
-# ==================== FastAPI Setup ====================
-api = FastAPI(
-    title="HTML to PDF Converter API",
-    description="Convert HTML to PDF using Puppeteer",
-    version="1.0.0"
-)
-
-api.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-class HTMLRequest(BaseModel):
-    html: str
-    aspect_ratio: Optional[str] = "auto"
-    return_base64: Optional[bool] = False
-
-# ==================== Shared Functions ====================
-def detect_aspect_ratio(html_content):
-    """Detect aspect ratio from HTML content"""
-    viewport_match = re.search(r'<meta[^>]*viewport[^>]*content=["\']([^"\']*)["\']', html_content, re.IGNORECASE)
-    if viewport_match:
-        viewport = viewport_match.group(1).lower()
-        if 'width=device-width' in viewport or 'width=100%' in viewport:
-            if 'orientation=portrait' in viewport:
-                return "9:16"
-            elif 'orientation=landscape' in viewport:
-                return "16:9"
-    
-    aspect_match = re.search(r'aspect-ratio\s*:\s*(\d+)\s*/\s*(\d+)', html_content, re.IGNORECASE)
-    if aspect_match:
-        width = int(aspect_match.group(1))
-        height = int(aspect_match.group(2))
-        ratio = width / height
-        if ratio > 1.5:
-            return "16:9"
-        elif ratio < 0.7:
-            return "9:16"
-        else:
-            return "1:1"
-    
-    if any(keyword in html_content.lower() for keyword in ['reveal.js', 'impress.js', 'slide', 'presentation']):
-        return "16:9"
-    
-    body_match = re.search(r'<body[^>]*style=["\']([^"\']*)["\']', html_content, re.IGNORECASE)
-    if body_match:
-        style = body_match.group(1).lower()
-        if 'width' in style and 'height' in style:
-            width_match = re.search(r'width\s*:\s*(\d+)', style)
-            height_match = re.search(r'height\s*:\s*(\d+)', style)
-            if width_match and height_match:
-                w = int(width_match.group(1))
-                h = int(height_match.group(1))
-                ratio = w / h
-                if ratio > 1.5:
-                    return "16:9"
-                elif ratio < 0.7:
-                    return "9:16"
-    
-    return "9:16"
-
-def convert_html_to_pdf(html_content, aspect_ratio):
-    """Convert HTML content to PDF using Puppeteer"""
-    temp_dir = None
-    try:
-        temp_dir = tempfile.mkdtemp()
-        
-        if aspect_ratio == "auto":
-            aspect_ratio = detect_aspect_ratio(html_content)
-        
-        if aspect_ratio not in ["16:9", "1:1", "9:16"]:
-            aspect_ratio = "9:16"
-        
-        style_injection = """
-        <style>
-            @page {
-                margin: 0;
-            }
-            * {
-                -webkit-print-color-adjust: exact !important;
-                print-color-adjust: exact !important;
-                color-adjust: exact !important;
-            }
-            body {
-                -webkit-print-color-adjust: exact !important;
-                print-color-adjust: exact !important;
-            }
-        </style>
-        """
-        
-        if '</head>' in html_content:
-            html_content = html_content.replace('</head>', style_injection + '</head>')
-        elif '<body' in html_content:
-            html_content = html_content.replace('<body', style_injection + '<body', 1)
-        else:
-            html_content = style_injection + html_content
-        
-        html_file = os.path.join(temp_dir, "input.html")
-        with open(html_file, 'w', encoding='utf-8') as f:
-            f.write(html_content)
-        
-        script_dir = os.path.dirname(os.path.abspath(__file__))
-        puppeteer_script = os.path.join(os.path.dirname(script_dir), 'puppeteer_pdf.js')
-        
-        result = subprocess.run(
-            ['node', puppeteer_script, html_file, aspect_ratio],
-            capture_output=True,
-            text=True,
-            timeout=60,
-            cwd=os.path.dirname(script_dir)
-        )
-        
-        if result.returncode != 0:
-            return None, f"PDF conversion failed: {result.stderr}"
-        
-        pdf_file = html_file.replace('.html', '.pdf')
-        
-        if not os.path.exists(pdf_file):
-            return None, "PDF file was not generated"
-        
-        with open(pdf_file, 'rb') as f:
-            pdf_bytes = f.read()
-        
-        shutil.rmtree(temp_dir, ignore_errors=True)
-        
-        return pdf_bytes, None
-        
-    except subprocess.TimeoutExpired:
-        if temp_dir:
-            shutil.rmtree(temp_dir, ignore_errors=True)
-        return None, "Error: PDF conversion timed out (60 seconds)"
-    except Exception as e:
-        if temp_dir:
-            shutil.rmtree(temp_dir, ignore_errors=True)
-        return None, f"Error: {str(e)}"
-
-# ==================== FastAPI Endpoints ====================
-@api.get("/")
-async def root():
-    return {
-        "message": "HTML to PDF Converter API",
-        "version": "1.0.0",
-        "endpoints": {
-            "POST /api/convert": "Convert HTML to PDF",
-            "GET /api/health": "Health check"
-        },
-        "docs": "/docs"
-    }
-
-@api.get("/api/health")
-async def health():
-    return {"status": "healthy", "service": "html-to-pdf"}
-
-@api.post("/api/convert")
-async def convert_html(request: HTMLRequest):
-    """Convert HTML to PDF via API"""
-    try:
-        pdf_bytes, error = convert_html_to_pdf(request.html, request.aspect_ratio)
-        
-        if error:
-            raise HTTPException(status_code=500, detail=error)
-        
-        if request.return_base64:
-            pdf_base64 = base64.b64encode(pdf_bytes).decode('utf-8')
-            return {
-                "success": True,
-                "pdf_base64": pdf_base64,
-                "size": len(pdf_bytes),
-                "aspect_ratio": request.aspect_ratio
-            }
-        else:
-            return Response(
-                content=pdf_bytes,
-                media_type="application/pdf",
-                headers={
-                    "Content-Disposition": "attachment; filename=converted.pdf"
-                }
-            )
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-# ==================== Streamlit UI ====================
-def render_html_preview(html_content):
-    b64 = base64.b64encode(html_content.encode()).decode()
-    iframe_html = f'<iframe src="data:text/html;base64,{b64}" width="100%" height="600" style="border: 2px solid #ddd; border-radius: 5px;"></iframe>'
-    return iframe_html
-
-def render_pdf_preview(pdf_bytes):
-    b64 = base64.b64encode(pdf_bytes).decode()
-    pdf_display = f'<iframe src="data:application/pdf;base64,{b64}" width="100%" height="600" style="border: 2px solid #ddd; border-radius: 5px;" type="application/pdf"></iframe>'
-    return pdf_display
-
-# Start FastAPI in background
-def run_api():
-    uvicorn.run(api, host="0.0.0.0", port=7860, log_level="info")
-
-# Start API server in a separate thread
-if 'api_started' not in st.session_state:
-    api_thread = Thread(target=run_api, daemon=True)
-    api_thread.start()
-    st.session_state.api_started = True
-
-# Streamlit Configuration
-st.set_page_config(
-    page_title="HTML to PDF Converter",
-    page_icon="📄",
-    layout="wide"
-)
-
-# Page header
-st.title("📄 HTML to PDF Converter")
-st.markdown("""
-Convert HTML files or HTML code to PDF using Puppeteer with automatic aspect ratio detection.  
-Preserves styles, fonts, colors, and layout.
-""")
-
-# API Info Banner
-st.info("""
-🚀 **API Mode Enabled!** You can now use this service via REST API:
-- **Endpoint**: `POST /api/convert`
-- **Docs**: [/docs](/docs) for interactive API documentation
-- **Health Check**: `GET /api/health`
-""")
-
-# Create tabs
-tab1, tab2, tab3 = st.tabs(["📤 Upload HTML File", "📝 Paste HTML Code", "🔌 API Documentation"])
-
-# Tab 1: Upload HTML File
-with tab1:
-    uploaded_file = st.file_uploader(
-        "Choose an HTML file",
-        type=['html', 'htm'],
-        key="file_uploader",
-        help="Upload an HTML file (max 200MB)",
-        accept_multiple_files=False
-    )
-    
-    if uploaded_file is not None:
-        st.success(f"✅ File uploaded: {uploaded_file.name} ({uploaded_file.size:,} bytes)")
-        
-        uploaded_file.seek(0)
-        try:
-            html_content = uploaded_file.getvalue().decode('utf-8')
-        except UnicodeDecodeError:
-            uploaded_file.seek(0)
-            html_content = uploaded_file.getvalue().decode('latin-1')
-        
-        detected_ratio = detect_aspect_ratio(html_content)
-        
-        col1, col2 = st.columns([1, 1])
-        
-        with col1:
-            st.subheader("⚙️ Settings")
-            
-            auto_detect = st.checkbox("Auto-detect aspect ratio", value=True, key="auto_detect_file")
-            
-            if auto_detect:
-                aspect_ratio_file = detected_ratio
-                st.info(f"🔍 Detected: **{detected_ratio}**")
-            else:
-                aspect_ratio_file = st.radio(
-                    "Aspect Ratio",
-                    options=["16:9", "1:1", "9:16"],
-                    index=["16:9", "1:1", "9:16"].index(detected_ratio),
-                    key="aspect_file",
-                    help="Select the page orientation and dimensions"
-                )
-            
-            st.markdown(f"""
-            **Selected: {aspect_ratio_file}**
-            - 16:9 = Landscape (297mm × 210mm)
-            - 1:1 = Square (210mm × 210mm)
-            - 9:16 = Portrait (210mm × 297mm)
-            """)
-            
-            convert_file_btn = st.button("🔄 Convert to PDF", key="convert_file", type="primary", use_container_width=True)
-        
-        with col2:
-            st.subheader("👁️ HTML Preview")
-            with st.expander("Show HTML Preview", expanded=False):
-                st.components.v1.html(render_html_preview(html_content), height=600, scrolling=True)
-        
-        if convert_file_btn:
-            with st.spinner("Converting HTML to PDF..."):
-                pdf_bytes, error = convert_html_to_pdf(html_content, aspect_ratio_file)
-                
-                if error:
-                    st.error(f"❌ {error}")
-                    with st.expander("Show error details"):
-                        st.code(error)
-                else:
-                    st.success("✅ PDF generated successfully!")
-                    
-                    col_a, col_b = st.columns([1, 1])
-                    
-                    with col_a:
-                        output_filename = uploaded_file.name.replace('.html', '.pdf').replace('.htm', '.pdf')
-                        if not output_filename.endswith('.pdf'):
-                            output_filename += '.pdf'
-                        
-                        st.download_button(
-                            label="⬇️ Download PDF",
-                            data=pdf_bytes,
-                            file_name=output_filename,
-                            mime="application/pdf",
-                            use_container_width=True,
-                            key="download_file_pdf"
-                        )
-                    
-                    with col_b:
-                        st.info(f"📦 Size: {len(pdf_bytes):,} bytes")
-                    
-                    st.subheader("📄 PDF Preview")
-                    st.components.v1.html(render_pdf_preview(pdf_bytes), height=600, scrolling=True)
-
-# Tab 2: Paste HTML Code
-with tab2:
-    col1, col2 = st.columns([1, 1])
-    
-    with col1:
-        html_code = st.text_area(
-            "HTML Content",
-            value="""<!DOCTYPE html>
-<html>
-<head>
-    <title>Sample Document</title>
-    <style>
-        body {
-            font-family: Arial, sans-serif;
-            margin: 40px;
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            color: white;
-        }
-        h1 {
-            font-size: 48px;
-            margin-bottom: 20px;
-            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
-        }
-        p {
-            font-size: 18px;
-            line-height: 1.6;
-        }
-        .box {
-            background: rgba(255,255,255,0.1);
-            padding: 20px;
-            border-radius: 10px;
-            margin-top: 20px;
-        }
-    </style>
-</head>
-<body>
-    <h1>Hello, PDF World! 🌍</h1>
-    <p>This is a sample HTML document converted to PDF.</p>
-    <div class="box">
-        <p>✨ Styles, colors, and gradients are preserved!</p>
-    </div>
-</body>
-</html>""",
-            height=400,
-            key="html_code"
-        )
-        
-        if html_code and html_code.strip():
-            detected_ratio_text = detect_aspect_ratio(html_code)
-            
-            auto_detect_text = st.checkbox("Auto-detect aspect ratio", value=True, key="auto_detect_text")
-            
-            if auto_detect_text:
-                aspect_ratio_text = detected_ratio_text
-                st.info(f"🔍 Detected: **{detected_ratio_text}**")
-            else:
-                aspect_ratio_text = st.radio(
-                    "Aspect Ratio",
-                    options=["16:9", "1:1", "9:16"],
-                    index=["16:9", "1:1", "9:16"].index(detected_ratio_text),
-                    key="aspect_text",
-                    help="Select the page orientation and dimensions"
-                )
-            
-            convert_text_btn = st.button("🔄 Convert to PDF", key="convert_text", type="primary", use_container_width=True)
-        else:
-            convert_text_btn = False
-    
-    with col2:
-        if html_code and html_code.strip():
-            st.subheader("👁️ HTML Preview")
-            with st.expander("Show HTML Preview", expanded=False):
-                st.components.v1.html(render_html_preview(html_code), height=600, scrolling=True)
-    
-    if convert_text_btn and html_code and html_code.strip():
-        with st.spinner("Converting HTML to PDF..."):
-            pdf_bytes, error = convert_html_to_pdf(html_code, aspect_ratio_text)
-            
-            if error:
-                st.error(f"❌ {error}")
-                with st.expander("Show error details"):
-                    st.code(error)
-            else:
-                st.success("✅ PDF generated successfully!")
-                
-                col_a, col_b = st.columns([1, 1])
-                
-                with col_a:
-                    st.download_button(
-                        label="⬇️ Download PDF",
-                        data=pdf_bytes,
-                        file_name="converted.pdf",
-                        mime="application/pdf",
-                        use_container_width=True,
-                        key="download_text_pdf"
-                    )
-                
-                with col_b:
-                    st.info(f"📦 Size: {len(pdf_bytes):,} bytes")
-                
-                st.subheader("📄 PDF Preview")
-                st.components.v1.html(render_pdf_preview(pdf_bytes), height=600, scrolling=True)
-
-# Tab 3: API Documentation
-with tab3:
-    st.header("🔌 API Documentation")
-    
-    st.markdown("""
-    ### Base URL
-    ```
-    https://your-space-name.hf.space
-    ```
-    
-    ### Endpoints
-    
-    #### 1. Health Check
-    ```http
-    GET /api/health
-    ```
-    
-    **Response:**
-    ```json
-    {
-        "status": "healthy",
-        "service": "html-to-pdf"
-    }
-    ```
-    
-    #### 2. Convert HTML to PDF
-    ```http
-    POST /api/convert
-    Content-Type: application/json
-    ```
-    
-    **Request Body:**
-    ```json
-    {
-        "html": "<html><body><h1>Hello World</h1></body></html>",
-        "aspect_ratio": "auto",
-        "return_base64": false
-    }
-    ```
-    
-    **Parameters:**
-    - `html` (required): HTML content as string
-    - `aspect_ratio` (optional): "auto", "16:9", "1:1", or "9:16" (default: "auto")
-    - `return_base64` (optional): Return PDF as base64 string (default: false)
-    
-    **Response (return_base64=false):**
-    - Returns PDF file directly with `Content-Type: application/pdf`
-    
-    **Response (return_base64=true):**
-    ```json
-    {
-        "success": true,
-        "pdf_base64": "JVBERi0xLjQKJeLjz9...",
-        "size": 12345,
-        "aspect_ratio": "9:16"
-    }
-    ```
-    
-    ### Example Usage
-    
-    #### Python
-    ```python
-    import requests
-    
-    url = "https://your-space-name.hf.space/api/convert"
-    
-    payload = {
-        "html": "<html><body><h1>Test PDF</h1></body></html>",
-        "aspect_ratio": "auto",
-        "return_base64": false
-    }
-    
-    response = requests.post(url, json=payload)
-    
-    # Save PDF
-    with open("output.pdf", "wb") as f:
-        f.write(response.content)
-    ```
-    
-    #### JavaScript
-    ```javascript
-    const response = await fetch('https://your-space-name.hf.space/api/convert', {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            html: '<html><body><h1>Test PDF</h1></body></html>',
-            aspect_ratio: 'auto',
-            return_base64: false
-        })
-    });
-    
-    const blob = await response.blob();
-    // Download or use the PDF blob
-    ```
-    
-    #### cURL
-    ```bash
-    curl -X POST "https://your-space-name.hf.space/api/convert" \\
-         -H "Content-Type: application/json" \\
-         -d '{"html":"<html><body><h1>Test</h1></body></html>","aspect_ratio":"auto"}' \\
-         --output output.pdf
-    ```
-    """)
-
-# Footer
-st.markdown("---")
-st.markdown("""
-### 💡 Tips:
-- **Auto-detection** analyzes your HTML to suggest the best aspect ratio
-- **16:9** - Best for presentations and landscape documents (297mm × 210mm)
-- **1:1** - Square format (210mm × 210mm)
-- **9:16** - Portrait format, standard A4 (210mm × 297mm)
-- All CSS styles, colors, gradients, and fonts are preserved
-- Use inline CSS or `<style>` tags for best results
-- External resources should use absolute URLs
-
-### 🔗 API Access
-- **Interactive Docs**: Visit `/docs` for Swagger UI
-- **Alternative Docs**: Visit `/redoc` for ReDoc UI
-""")