Update app.py

app.py

@@ -4,50 +4,51 @@ import logging
 from fastapi import FastAPI, File, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
 
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
 app = FastAPI()
 
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
-    allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
+def safe_float(value, default=0.0):
+    """Guards against NoneType conversion errors."""
+    try:
+        if value is None:
+            return default
+        return float(value)
+    except (TypeError, ValueError):
+        return default
+
 def normalize_color(color):
-    """Safely converts any PDF color format to Figma RGB format."""
+    """Safely converts PDF color components to Figma 0-1 RGB."""
+    if color is None:
+        return None  # Signal to Figma that there is no fill/stroke
+    
     try:
-        # If the PDF doesn't define a color for this element, return None
-        # This tells Figma not to apply a fill or stroke
-        if color is None:
-            return None
-            
-        # Handle integer colors (e.g., 16711680 for Red)
+        # If it's an integer, convert to RGB tuple first
         if isinstance(color, int):
             color = fitz.utils.getColor(color)
         
-        # Ensure it's a list/tuple of numbers
+        # Ensure we are working with a list or tuple
         if not isinstance(color, (list, tuple)):
             return {"r": 0, "g": 0, "b": 0}
 
-        # Convert to 0.0 - 1.0 range based on component count
-        if len(color) == 1: # Grayscale
-            val = float(color[0])
-            return {"r": val, "g": val, "b": val}
-        elif len(color) >= 3: # RGB or CMYK (taking first 3)
-            return {"r": float(color[0]), "g": float(color[1]), "b": float(color[2])}
-        
-        return {"r": 0, "g": 0, "b": 0}
-    except Exception as e:
-        logger.error(f"Color error: {e}")
+        # Normalize based on color space
+        if len(color) == 1:  # Grayscale
+            c = safe_float(color[0])
+            return {"r": c, "g": c, "b": c}
+        elif len(color) >= 3:  # RGB or CMYK
+            return {
+                "r": safe_float(color[0]),
+                "g": safe_float(color[1]),
+                "b": safe_float(color[2])
+            }
+    except Exception:
         return {"r": 0, "g": 0, "b": 0}
-
-@app.get("/")
-async def root():
-    return {"status": "PDF Converter is Online"}
+    return None
 
 @app.post("/convert")
 async def convert_pdf(file: UploadFile = File(...)):
@@ -58,63 +59,61 @@ async def convert_pdf(file: UploadFile = File(...)):
 
         for page in doc:
             page_dict = {
-                "width": float(page.rect.width),
-                "height": float(page.rect.height),
+                "width": safe_float(page.rect.width),
+                "height": safe_float(page.rect.height),
                 "elements": []
             }
 
-            # 1. Text and Images
+            # 1. Text & Images
             raw_dict = page.get_text("dict")
-            for block in raw_dict["blocks"]:
+            for block in raw_dict.get("blocks", []):
                 if block.get("type") == 0:  # TEXT
                     for line in block.get("lines", []):
                         for span in line.get("spans", []):
                             page_dict["elements"].append({
                                 "type": "TEXT",
                                 "content": span.get("text", ""),
-                                "x": float(span["bbox"][0]),
-                                "y": float(span["bbox"][1]),
-                                "size": float(span.get("size", 12)),
+                                "x": safe_float(span["bbox"][0]),
+                                "y": safe_float(span["bbox"][1]),
+                                "size": safe_float(span.get("size"), 12),
                                 "color": normalize_color(span.get("color"))
                             })
                 elif block.get("type") == 1:  # IMAGE
                     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])
+                        "x": safe_float(block["bbox"][0]),
+                        "y": safe_float(block["bbox"][1]),
+                        "width": safe_float(block["bbox"][2] - block["bbox"][0]),
+                        "height": safe_float(block["bbox"][3] - block["bbox"][1])
                     })
 
             # 2. Vector Drawings
             for path in page.get_drawings():
-                svg_path = ""
+                d_path = ""
                 for item in path.get("items", []):
                     if item[0] == "l": 
-                        svg_path += f"M {item[1].x} {item[1].y} L {item[2].x} {item[2].y} "
+                        d_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} "
+                        d_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 "
+                        d_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:
+                if d_path:
                     page_dict["elements"].append({
                         "type": "VECTOR",
-                        "path": svg_path.strip(),
+                        "path": d_path.strip(),
                         "fill": normalize_color(path.get("fill")),
                         "stroke": normalize_color(path.get("color")),
-                        "strokeWeight": float(path.get("width", 1))
+                        "strokeWeight": safe_float(path.get("width"), 1.0)
                     })
 
             pages_data.append(page_dict)
         
         doc.close()
         return {"pages": pages_data}
-
     except Exception as e:
-        logger.error(f"Global Error: {str(e)}")
         return {"error": str(e)}
 
 if __name__ == "__main__":