Update app.py

app.py

@@ -4,85 +4,137 @@ import logging
 from fastapi import FastAPI, File, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
 
+# Set up logging for Hugging Face console
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 app = FastAPI()
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
+# Enable CORS for Figma Plugin access
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
 def safe_f(val, default=0.0):
-    """Ultimate guard for float conversion"""
-    if val is None: return default
-    try: return float(val)
-    except: return default
+    """Guards against float(None) errors."""
+    if val is None:
+        return default
+    try:
+        return float(val)
+    except (TypeError, ValueError):
+        return default
 
 def get_figma_color(color):
-    """Converts PDF color to Figma RGB safely"""
-    if color is None: return None
+    """Converts various PDF color formats to Figma 0-1 RGB."""
+    if color is None:
+        return None
     try:
-        # If color is int, convert to RGB tuple
+        # If color is an integer, convert to RGB tuple
         if isinstance(color, int):
             color = fitz.utils.getColor(color)
         
-        if not isinstance(color, (list, tuple)): return None
+        if not isinstance(color, (list, tuple)):
+            return None
+
+        # Handle Grayscale (1 component)
+        if len(color) == 1:
+            val = safe_f(color[0])
+            return {"r": val, "g": val, "b": val}
         
-        if len(color) == 1: # Grayscale
-            return {"r": safe_f(color[0]), "g": safe_f(color[0]), "b": safe_f(color[0])}
-        elif len(color) >= 3: # RGB
-            return {"r": safe_f(color[0]), "g": safe_f(color[1]), "b": safe_f(color[2])}
-    except: return None
+        # Handle RGB/CMYK (take first 3)
+        if len(color) >= 3:
+            return {
+                "r": safe_f(color[0]),
+                "g": safe_f(color[1]),
+                "b": safe_f(color[2])
+            }
+    except Exception:
+        return None
     return None
 
+@app.get("/")
+async def root():
+    return {"status": "PDF Converter is Online", "engine": "PyMuPDF"}
+
 @app.post("/convert")
 async def convert_pdf(file: UploadFile = File(...)):
     try:
-        data = await file.read()
-        doc = fitz.open(stream=data, filetype="pdf")
+        logger.info(f"Processing: {file.filename}")
+        pdf_bytes = await file.read()
+        doc = fitz.open(stream=pdf_bytes, filetype="pdf")
         pages_data = []
 
         for page in doc:
-            p_dict = {"width": safe_f(page.rect.width), "height": safe_f(page.rect.height), "elements": []}
-            
-            # 1. Extraction via Dictionary (Text & Images)
-            raw = page.get_text("dict")
-            for block in raw.get("blocks", []):
-                if block.get("type") == 0: # TEXT
+            page_dict = {
+                "width": safe_f(page.rect.width),
+                "height": safe_f(page.rect.height),
+                "elements": []
+            }
+
+            # 1. TEXT AND IMAGES (using dict for structured layout)
+            raw_dict = page.get_text("dict")
+            for block in raw_dict.get("blocks", []):
+                # Type 0 is Text
+                if block.get("type") == 0:
                     for line in block.get("lines", []):
-                        for s in line.get("spans", []):
-                            p_dict["elements"].append({
+                        for span in line.get("spans", []):
+                            page_dict["elements"].append({
                                 "type": "TEXT",
-                                "content": s.get("text", ""),
-                                "x": safe_f(s["bbox"][0]), "y": safe_f(s["bbox"][1]),
-                                "size": safe_f(s.get("size"), 12),
-                                "color": get_figma_color(s.get("color"))
+                                "content": span.get("text", ""),
+                                "x": safe_f(span["bbox"][0]),
+                                "y": safe_f(span["bbox"][1]),
+                                "size": safe_f(span.get("size"), 12.0),
+                                "color": get_figma_color(span.get("color"))
                             })
-                elif block.get("type") == 1: # IMAGE
-                    p_dict["elements"].append({
+                # Type 1 is Image
+                elif block.get("type") == 1:
+                    page_dict["elements"].append({
                         "type": "IMAGE",
                         "bytes": base64.b64encode(block["image"]).decode("utf-8"),
-                        "x": safe_f(block["bbox"][0]), "y": safe_f(block["bbox"][1]),
+                        "x": safe_f(block["bbox"][0]),
+                        "y": safe_f(block["bbox"][1]),
                         "width": safe_f(block["bbox"][2] - block["bbox"][0]),
                         "height": safe_f(block["bbox"][3] - block["bbox"][1])
                     })
 
-            # 2. Extraction via Drawings (Vectors)
+            # 2. VECTOR DRAWINGS (Paths, Lines, Rectangles)
             for path in page.get_drawings():
                 d_path = ""
                 for item in path.get("items", []):
-                    if item[0] == "l": d_path += f"M {safe_f(item[1].x)} {safe_f(item[1].y)} L {safe_f(item[2].x)} {safe_f(item[2].y)} "
+                    # Line
+                    if item[0] == "l":
+                        d_path += f"M {safe_f(item[1].x)} {safe_f(item[1].y)} L {safe_f(item[2].x)} {safe_f(item[2].y)} "
+                    # Rectangle
                     elif item[0] == "re":
                         r = item[1]
                         d_path += f"M {safe_f(r.x0)} {safe_f(r.y0)} L {safe_f(r.x1)} {safe_f(r.y0)} L {safe_f(r.x1)} {safe_f(r.y1)} L {safe_f(r.x0)} {safe_f(r.y1)} Z "
+                    # Curve
                     elif item[0] == "c":
-                        d_path += f"M {safe_f(item[1].x)} {safe_f(item[1].y)} C {safe_f(item[2].x)} {safe_f(item[2].y)} {safe_f(item[3].x} {safe_f(item[3].y)} {safe_f(item[4].x)} {safe_f(item[4].y)} "
+                        d_path += f"M {safe_f(item[1].x)} {safe_f(item[1].y)} C {safe_f(item[2].x)} {safe_f(item[2].y)} {safe_f(item[3].x)} {safe_f(item[3].y)} {safe_f(item[4].x)} {safe_f(item[4].y)} "
                 
                 if d_path:
-                    p_dict["elements"].append({
+                    page_dict["elements"].append({
                         "type": "VECTOR",
                         "path": d_path.strip(),
                         "fill": get_figma_color(path.get("fill")),
                         "stroke": get_figma_color(path.get("color")),
                         "strokeWeight": safe_f(path.get("width"), 1.0)
                     })
-            pages_data.append(p_dict)
+
+            pages_data.append(page_dict)
+        
         doc.close()
         return {"pages": pages_data}
+
     except Exception as e:
-        return {"error": str(e)}
+        logger.error(f"Error during conversion: {str(e)}")
+        return {"error": str(e)}
+
+if __name__ == "__main__":
+    import uvicorn
+    # Important: Hugging Face uses port 7860
+    uvicorn.run(app, host="0.0.0.0", port=7860)