htmlpdfs

Sleeping

App Files Files Community

ABDALLALSWAITI commited on Oct 17, 2025

Commit

f9f8ffb

verified ·

1 Parent(s): dd2814d

Update app.py

Browse files

Files changed (1) hide show

app.py +152 -159

app.py CHANGED Viewed

@@ -1,5 +1,5 @@
 from fastapi import FastAPI, UploadFile, File, Form, HTTPException
-from fastapi.responses import Response, JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 import subprocess
 import os
@@ -9,13 +9,15 @@ import base64
 import re
 import mimetypes
 from typing import List, Optional
 app = FastAPI(
-    title="HTML to PDF Converter API",
-    description="Convert HTML to PDF with image support",
-    version="1.0.0",
-    docs_url="/",
-    redoc_url="/redoc"
 )
 app.add_middleware(
@@ -26,139 +28,137 @@ app.add_middleware(
     allow_headers=["*"],
 )
-def detect_aspect_ratio(html_content: str) -> str:
-    viewport_match = re.search(r'<meta[^>]*viewport[^>]*content=["\']([^"\']*)["\']', html_content, re.IGNORECASE)
-    if viewport_match:
-        viewport = viewport_match.group(1).lower()
-        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"
     return "9:16"
-def image_to_base64(image_bytes: bytes, filename: str) -> str:
-    mime_type, _ = mimetypes.guess_type(filename)
-    if not mime_type:
-        ext = os.path.splitext(filename)[1].lower()
-        mime_map = {
-            '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
-            '.png': 'image/png', '.gif': 'image/gif',
-            '.svg': 'image/svg+xml', '.webp': 'image/webp',
-            '.bmp': 'image/bmp'
-        }
-        mime_type = mime_map.get(ext, 'image/png')
-    b64_data = base64.b64encode(image_bytes).decode('utf-8')
-    return f"data:{mime_type};base64,{b64_data}"
-def embed_images(html_content: str, images_dict: dict) -> str:
-    if not images_dict:
-        return html_content
-    for filename, data_url in images_dict.items():
-        escaped_name = re.escape(filename)
-        pattern1 = rf'(<img[^>]*\s+src\s*=\s*)(["\'])(?:[^"\']*?/)?{escaped_name}\2'
-        html_content = re.sub(pattern1, rf'\1\2{data_url}\2', html_content, flags=re.IGNORECASE | re.DOTALL)
-        pattern2 = rf'(background-image\s*:\s*url\s*\()(["\']?)(?:[^)"\']*/)?{escaped_name}\2(\))'
-        html_content = re.sub(pattern2, rf'\1"{data_url}"\3', html_content, flags=re.IGNORECASE)
-        pattern3 = rf'(url\s*\()(["\']?)(?:[^)"\']*/)?{escaped_name}\2(\))'
-        html_content = re.sub(pattern3, rf'\1"{data_url}"\3', html_content, flags=re.IGNORECASE)
-    return html_content
-def inject_page_breaks(html_content: str, aspect_ratio: str) -> str:
-    if aspect_ratio == "16:9":
-        page_size = "A4 landscape"
-    elif aspect_ratio == "1:1":
-        page_size = "210mm 210mm"
-    else:
-        page_size = "A4 portrait"
-    page_css = f"""
-    <style id="auto-page-breaks">
-        @page {{ size: {page_size}; margin: 0; }}
-        html, body {{ margin: 0 !important; padding: 0 !important; width: 100% !important; height: 100% !important; }}
-        .page, .slide, section.page, article.page, div[class*="page"], div[class*="slide"] {{
-            width: 100% !important; min-height: 100vh !important; height: 100vh !important;
-            page-break-after: always !important; break-after: page !important;
-            page-break-inside: avoid !important; break-inside: avoid !important;
-            position: relative !important; box-sizing: border-box !important; overflow: hidden !important;
-        }}
-        .page:last-child, .slide:last-child, section.page:last-child, article.page:last-child {{
-            page-break-after: auto !important; break-after: auto !important;
-        }}
-        body > section:not(.no-page-break), body > article:not(.no-page-break), body > div:not(.no-page-break) {{
-            page-break-after: always !important; break-after: page !important; min-height: 100vh;
-        }}
-        body > section:last-child, body > article:last-child, body > div:last-child {{
-            page-break-after: auto !important;
-        }}
-        .page-break, .page-break-after {{ page-break-after: always !important; break-after: page !important; }}
-        .page-break-before {{ page-break-before: always !important; break-before: page !important; }}
-        .no-page-break, .keep-together {{ page-break-inside: avoid !important; break-inside: avoid !important; }}
-        h1, h2, h3, h4, h5, h6 {{ page-break-after: avoid !important; break-after: avoid !important; }}
-        img, figure, table, pre, blockquote {{ page-break-inside: avoid !important; break-inside: avoid !important; }}
-        * {{ -webkit-print-color-adjust: exact !important; print-color-adjust: exact !important; }}
-    </style>
-    """
-    if '</head>' in html_content:
-        html_content = html_content.replace('</head>', page_css + '</head>')
-    elif '<body' in html_content:
-        html_content = html_content.replace('<body', page_css + '<body', 1)
-    else:
-        html_content = page_css + html_content
-    return html_content
-def convert_to_pdf(html_content: str, aspect_ratio: str, temp_dir: str) -> bytes:
-    html_content = inject_page_breaks(html_content, aspect_ratio)
-    html_file = os.path.join(temp_dir, "input.html")
-    with open(html_file, 'w', encoding='utf-8') as f:
-        f.write(html_content)
-    puppeteer_script = '/app/puppeteer_pdf.js'
-    if not os.path.exists(puppeteer_script):
-        raise Exception("puppeteer_pdf.js not found")
-    result = subprocess.run(
-        ['node', puppeteer_script, html_file, aspect_ratio],
-        capture_output=True, text=True, timeout=60
-    )
-    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:
-        return f.read()
-@app.get("/health")
-async def health():
-    return {"status": "healthy", "service": "HTML to PDF API", "version": "1.0.0"}
 @app.post("/convert")
 async def convert(
@@ -167,12 +167,11 @@ async def convert(
     auto_detect: bool = Form(True),
     images: Optional[List[UploadFile]] = File(None)
 ):
-    temp_dir = None
     try:
-        html_content = (await html_file.read()).decode('utf-8')
         if auto_detect:
-            aspect_ratio = detect_aspect_ratio(html_content)
         elif not aspect_ratio:
             aspect_ratio = "9:16"
@@ -180,25 +179,25 @@ async def convert(
             raise HTTPException(400, "Invalid aspect ratio")
         if images:
-            images_dict = {}
             for img in images:
                 img_bytes = await img.read()
-                images_dict[img.filename] = image_to_base64(img_bytes, img.filename)
-            html_content = embed_images(html_content, images_dict)
-        temp_dir = tempfile.mkdtemp()
-        pdf_bytes = convert_to_pdf(html_content, aspect_ratio, temp_dir)
         return Response(
-            content=pdf_bytes,
             media_type="application/pdf",
             headers={"Content-Disposition": "attachment; filename=output.pdf"}
         )
     except Exception as e:
         raise HTTPException(500, str(e))
-    finally:
-        if temp_dir and os.path.exists(temp_dir):
-            shutil.rmtree(temp_dir, ignore_errors=True)
 @app.post("/convert-html")
 async def convert_html(
@@ -206,7 +205,6 @@ async def convert_html(
     aspect_ratio: Optional[str] = Form(None),
     auto_detect: bool = Form(True)
 ):
-    temp_dir = None
     try:
         if auto_detect:
             aspect_ratio = detect_aspect_ratio(html_content)
@@ -216,19 +214,17 @@ async def convert_html(
         if aspect_ratio not in ["16:9", "1:1", "9:16"]:
             raise HTTPException(400, "Invalid aspect ratio")
-        temp_dir = tempfile.mkdtemp()
-        pdf_bytes = convert_to_pdf(html_content, aspect_ratio, temp_dir)
         return Response(
-            content=pdf_bytes,
             media_type="application/pdf",
             headers={"Content-Disposition": "attachment; filename=output.pdf"}
         )
     except Exception as e:
         raise HTTPException(500, str(e))
-    finally:
-        if temp_dir and os.path.exists(temp_dir):
-            shutil.rmtree(temp_dir, ignore_errors=True)
 @app.post("/convert-base64")
 async def convert_base64(
@@ -236,7 +232,6 @@ async def convert_base64(
     aspect_ratio: Optional[str] = Form(None),
     auto_detect: bool = Form(True)
 ):
-    temp_dir = None
     try:
         if auto_detect:
             aspect_ratio = detect_aspect_ratio(html_content)
@@ -246,18 +241,16 @@ async def convert_base64(
         if aspect_ratio not in ["16:9", "1:1", "9:16"]:
             raise HTTPException(400, "Invalid aspect ratio")
-        temp_dir = tempfile.mkdtemp()
-        pdf_bytes = convert_to_pdf(html_content, aspect_ratio, temp_dir)
-        pdf_base64 = base64.b64encode(pdf_bytes).decode('utf-8')
         return JSONResponse({
             "success": True,
-            "pdf_base64": pdf_base64,
             "aspect_ratio": aspect_ratio,
-            "size_bytes": len(pdf_bytes)
         })
     except Exception as e:
-        raise HTTPException(500, str(e))
-    finally:
-        if temp_dir and os.path.exists(temp_dir):
-            shutil.rmtree(temp_dir, ignore_errors=True)

 from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.responses import Response, JSONResponse, HTMLResponse
 from fastapi.middleware.cors import CORSMiddleware
 import subprocess
 import os
 import re
 import mimetypes
 from typing import List, Optional
+import logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 app = FastAPI(
+    title="HTML to PDF Converter",
+    description="Convert HTML to PDF",
+    version="1.0.0"
 )
 app.add_middleware(
     allow_headers=["*"],
 )
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    return """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>HTML to PDF API</title>
+        <style>
+            body { font-family: Arial; max-width: 800px; margin: 50px auto; padding: 20px; }
+            h1 { color: #333; }
+            .endpoint { background: #f5f5f5; padding: 15px; margin: 10px 0; border-radius: 5px; }
+            code { background: #e0e0e0; padding: 2px 5px; border-radius: 3px; }
+        </style>
+    </head>
+    <body>
+        <h1>🔄 HTML to PDF Converter API</h1>
+        <p>Status: <strong style="color: green;">✓ Running</strong></p>
+        <h2>Endpoints:</h2>
+        <div class="endpoint">
+            <h3>GET /health</h3>
+            <p>Health check endpoint</p>
+        </div>
+        <div class="endpoint">
+            <h3>POST /convert</h3>
+            <p>Upload HTML file and convert to PDF</p>
+            <p>Parameters:</p>
+            <ul>
+                <li><code>html_file</code> - HTML file (required)</li>
+                <li><code>aspect_ratio</code> - 16:9, 1:1, or 9:16 (optional)</li>
+                <li><code>auto_detect</code> - Auto-detect aspect ratio (default: true)</li>
+                <li><code>images</code> - Image files to embed (optional)</li>
+            </ul>
+        </div>
+        <div class="endpoint">
+            <h3>POST /convert-html</h3>
+            <p>Convert HTML string to PDF</p>
+            <p>Parameters:</p>
+            <ul>
+                <li><code>html_content</code> - HTML as string (required)</li>
+                <li><code>aspect_ratio</code> - 16:9, 1:1, or 9:16 (optional)</li>
+            </ul>
+        </div>
+        <div class="endpoint">
+            <h3>POST /convert-base64</h3>
+            <p>Convert HTML to base64-encoded PDF</p>
+            <p>Returns JSON with base64 PDF data</p>
+        </div>
+        <h2>Documentation:</h2>
+        <p><a href="/docs">Interactive API Docs (Swagger)</a></p>
+        <p><a href="/redoc">Alternative Docs (ReDoc)</a></p>
+        <h2>Example Usage:</h2>
+        <pre>curl -X POST https://YOUR-SPACE.hf.space/convert-html \
+  -F "html_content=&lt;html&gt;&lt;body&gt;&lt;h1&gt;Hello PDF!&lt;/h1&gt;&lt;/body&gt;&lt;/html&gt;" \
+  -o output.pdf</pre>
+    </body>
+    </html>
+    """
+@app.get("/health")
+async def health():
+    logger.info("Health check requested")
+    return {
+        "status": "healthy",
+        "service": "HTML to PDF Converter",
+        "version": "1.0.0"
+    }
+def detect_aspect_ratio(html: str) -> str:
+    if 'orientation=portrait' in html.lower():
+        return "9:16"
+    if 'orientation=landscape' in html.lower():
+        return "16:9"
+    if any(k in html.lower() for k in ['slide', 'presentation']):
         return "16:9"
     return "9:16"
+def inject_page_css(html: str, ratio: str) -> str:
+    size = "A4 landscape" if ratio == "16:9" else "210mm 210mm" if ratio == "1:1" else "A4 portrait"
+    css = f"""<style>
+    @page {{ size: {size}; margin: 0; }}
+    html, body {{ margin: 0; padding: 0; width: 100%; height: 100%; }}
+    .page {{ width: 100%; height: 100vh; page-break-after: always; box-sizing: border-box; }}
+    .page:last-child {{ page-break-after: auto; }}
+    * {{ -webkit-print-color-adjust: exact; print-color-adjust: exact; }}
+    </style>"""
+    if '</head>' in html:
+        return html.replace('</head>', css + '</head>')
+    elif '<body' in html:
+        return html.replace('<body', css + '<body', 1)
+    return css + html
+def convert_to_pdf(html: str, ratio: str) -> bytes:
+    temp_dir = tempfile.mkdtemp()
+    try:
+        html = inject_page_css(html, ratio)
+        html_file = os.path.join(temp_dir, "input.html")
+        with open(html_file, 'w', encoding='utf-8') as f:
+            f.write(html)
+        logger.info(f"Converting with aspect ratio: {ratio}")
+        result = subprocess.run(
+            ['node', '/app/puppeteer_pdf.js', html_file, ratio],
+            capture_output=True,
+            text=True,
+            timeout=60
+        )
+        if result.returncode != 0:
+            logger.error(f"Conversion failed: {result.stderr}")
+            raise Exception(f"Conversion failed: {result.stderr}")
+        pdf_file = html_file.replace('.html', '.pdf')
+        if not os.path.exists(pdf_file):
+            raise Exception("PDF not generated")
+        with open(pdf_file, 'rb') as f:
+            return f.read()
+    finally:
+        shutil.rmtree(temp_dir, ignore_errors=True)
 @app.post("/convert")
 async def convert(
     auto_detect: bool = Form(True),
     images: Optional[List[UploadFile]] = File(None)
 ):
     try:
+        html = (await html_file.read()).decode('utf-8')
         if auto_detect:
+            aspect_ratio = detect_aspect_ratio(html)
         elif not aspect_ratio:
             aspect_ratio = "9:16"
             raise HTTPException(400, "Invalid aspect ratio")
         if images:
             for img in images:
                 img_bytes = await img.read()
+                b64 = base64.b64encode(img_bytes).decode()
+                ext = os.path.splitext(img.filename)[1].lower()
+                mime = f"image/{'jpeg' if ext in ['.jpg','.jpeg'] else 'png'}"
+                data_url = f"data:{mime};base64,{b64}"
+                html = html.replace(img.filename, data_url)
+        pdf = convert_to_pdf(html, aspect_ratio)
         return Response(
+            content=pdf,
             media_type="application/pdf",
             headers={"Content-Disposition": "attachment; filename=output.pdf"}
         )
     except Exception as e:
+        logger.error(f"Error: {str(e)}")
         raise HTTPException(500, str(e))
 @app.post("/convert-html")
 async def convert_html(
     aspect_ratio: Optional[str] = Form(None),
     auto_detect: bool = Form(True)
 ):
     try:
         if auto_detect:
             aspect_ratio = detect_aspect_ratio(html_content)
         if aspect_ratio not in ["16:9", "1:1", "9:16"]:
             raise HTTPException(400, "Invalid aspect ratio")
+        pdf = convert_to_pdf(html_content, aspect_ratio)
         return Response(
+            content=pdf,
             media_type="application/pdf",
             headers={"Content-Disposition": "attachment; filename=output.pdf"}
         )
     except Exception as e:
+        logger.error(f"Error: {str(e)}")
         raise HTTPException(500, str(e))
 @app.post("/convert-base64")
 async def convert_base64(
     aspect_ratio: Optional[str] = Form(None),
     auto_detect: bool = Form(True)
 ):
     try:
         if auto_detect:
             aspect_ratio = detect_aspect_ratio(html_content)
         if aspect_ratio not in ["16:9", "1:1", "9:16"]:
             raise HTTPException(400, "Invalid aspect ratio")
+        pdf = convert_to_pdf(html_content, aspect_ratio)
+        pdf_b64 = base64.b64encode(pdf).decode()
         return JSONResponse({
             "success": True,
+            "pdf_base64": pdf_b64,
             "aspect_ratio": aspect_ratio,
+            "size_bytes": len(pdf)
         })
     except Exception as e:
+        logger.error(f"Error: {str(e)}")
+        raise HTTPException(500, str(e))