Update app.py

app.py

@@ -1,72 +1,111 @@
 import fitz  # PyMuPDF
 import base64
+import logging
 from fastapi import FastAPI, File, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
 
+# Set up logging to see errors in the Hugging Face Log tab
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 app = FastAPI()
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
 def normalize_color(color):
-    if not color: return {"r": 0, "g": 0, "b": 0}
-    # PyMuPDF colors can be 1 (gray), 3 (rgb), or 4 (cmyk) components
-    if len(color) == 1: return {"r": color[0], "g": color[0], "b": color[0]}
-    return {"r": color[0], "g": color[1], "b": color[2]}
+    """Ensures color is always a 0-1 RGB dict for Figma"""
+    try:
+        if color is None: return {"r": 0, "g": 0, "b": 0}
+        # If color is an integer (from span['color'])
+        if isinstance(color, int):
+            color = fitz.utils.getColor(color)
+        
+        if len(color) == 1: # Grayscale
+            return {"r": float(color[0]), "g": float(color[0]), "b": float(color[0])}
+        return {"r": float(color[0]), "g": float(color[1]), "b": float(color[2])}
+    except:
+        return {"r": 0, "g": 0, "b": 0}
+
+@app.get("/")
+async def root():
+    return {"status": "PDF Converter is Online"}
 
 @app.post("/convert")
 async def convert_pdf(file: UploadFile = File(...)):
-    content = await file.read()
-    doc = fitz.open(stream=content, filetype="pdf")
-    pages_data = []
+    try:
+        logger.info(f"Processing file: {file.filename}")
+        content = await file.read()
+        doc = fitz.open(stream=content, filetype="pdf")
+        pages_data = []
+
+        for page in doc:
+            page_dict = {
+                "width": float(page.rect.width),
+                "height": float(page.rect.height),
+                "elements": []
+            }
+
+            # 1. Extract Text and Images
+            # Using "dict" captures font size, location, and images
+            raw_dict = page.get_text("dict")
+            for block in raw_dict["blocks"]:
+                if block["type"] == 0:  # Text Block
+                    for line in block["lines"]:
+                        for span in line["spans"]:
+                            page_dict["elements"].append({
+                                "type": "TEXT",
+                                "content": span["text"],
+                                "x": float(span["bbox"][0]),
+                                "y": float(span["bbox"][1]),
+                                "size": float(span["size"]),
+                                "color": normalize_color(span["color"])
+                            })
+                elif block["type"] == 1:  # Image Block
+                    page_dict["elements"].append({
+                        "type": "IMAGE",
+                        "bytes": base64.b64encode(block["image"]).decode("utf-8"),
+                        "x": float(block["bbox"][0]),
+                        "y": float(block["bbox"][1]),
+                        "width": float(block["bbox"][2] - block["bbox"][0]),
+                        "height": float(block["bbox"][3] - block["bbox"][1])
+                    })
 
-    for page in doc:
-        page_dict = {
-            "width": page.rect.width,
-            "height": page.rect.height,
-            "elements": []
-        }
+            # 2. Extract Vector Drawings (Paths)
+            for path in page.get_drawings():
+                svg_path = ""
+                for item in path["items"]:
+                    if item[0] == "l": # line
+                        svg_path += f"M {item[1].x} {item[1].y} L {item[2].x} {item[2].y} "
+                    elif item[0] == "c": # curve
+                        svg_path += f"M {item[1].x} {item[1].y} C {item[2].x} {item[2].y} {item[3].x} {item[3].y} {item[4].x} {item[4].y} "
+                    elif item[0] == "re": # rectangle
+                        r = item[1]
+                        svg_path += f"M {r.x0} {r.y0} L {r.x1} {r.y0} L {r.x1} {r.y1} L {r.x0} {r.y1} Z "
+                
+                if svg_path:
+                    page_dict["elements"].append({
+                        "type": "VECTOR",
+                        "path": svg_path.strip(),
+                        "fill": normalize_color(path.get("fill")),
+                        "stroke": normalize_color(path.get("color")),
+                        "strokeWeight": float(path.get("width", 1))
+                    })
 
-        # 1. Extract Text and Images using "dict"
-        raw = page.get_text("dict")
-        for block in raw["blocks"]:
-            if block["type"] == 0:  # TEXT
-                for line in block["lines"]:
-                    for span in line["spans"]:
-                        page_dict["elements"].append({
-                            "type": "TEXT",
-                            "content": span["text"],
-                            "x": span["bbox"][0],
-                            "y": span["bbox"][1],
-                            "size": span["size"],
-                            "color": normalize_color(fitz.utils.getColor(span["color"]))
-                        })
-            elif block["type"] == 1:  # IMAGE
-                page_dict["elements"].append({
-                    "type": "IMAGE",
-                    "bytes": base64.b64encode(block["image"]).decode("utf-8"),
-                    "x": block["bbox"][0], "y": block["bbox"][1],
-                    "width": block["bbox"][2] - block["bbox"][0],
-                    "height": block["bbox"][3] - block["bbox"][1]
-                })
+            pages_data.append(page_dict)
+        
+        doc.close()
+        return {"pages": pages_data}
 
-        # 2. Extract Vector Drawings
-        for path in page.get_drawings():
-            # Convert paths to SVG-like data for Figma's vectorPaths
-            svg_path = ""
-            for item in path["items"]:
-                if item[0] == "l": svg_path += f"M {item[1].x} {item[1].y} L {item[2].x} {item[2].y} "
-                elif item[0] == "c": svg_path += f"M {item[1].x} {item[1].y} C {item[2].x} {item[2].y} {item[3].x} {item[3].y} {item[4].x} {item[4].y} "
-                elif item[0] == "re": 
-                    r = item[1]
-                    svg_path += f"M {r.x0} {r.y0} L {r.x1} {r.y0} L {r.x1} {r.y1} L {r.x0} {r.y1} Z "
-            
-            if svg_path:
-                page_dict["elements"].append({
-                    "type": "VECTOR",
-                    "path": svg_path.strip(),
-                    "fill": normalize_color(path.get("fill")),
-                    "stroke": normalize_color(path.get("color")),
-                    "strokeWeight": path.get("width", 1)
-                })
+    except Exception as e:
+        logger.error(f"Conversion Error: {str(e)}")
+        return {"error": str(e)}
 
-        pages_data.append(page_dict)
-    return {"pages": pages_data}
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)