Update app.py

app.py

@@ -4,13 +4,19 @@ import base64
 from typing import List
 import tempfile
 import os
+import io
+import logging
 from fastapi.responses import JSONResponse
 
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
 app = FastAPI(title="PDF to Images API", description="API to convert PDF files to images for accounting automation")
 
 @app.post("/pdf_to_images", response_model=List[str])
 async def pdf_to_images(
-    file: UploadFile = File(...),
+    file: UploadFile = File(...), 
     dpi: int = Query(200, description="DPI for image conversion")
 ):
     # Validate file type
@@ -18,31 +24,121 @@ async def pdf_to_images(
         raise HTTPException(status_code=400, detail="Only PDF files are allowed")
     
     # Read the PDF content into memory
-    contents = await file.read()
+    try:
+        contents = await file.read()
+        logger.info(f"Successfully read PDF file: {file.filename}, size: {len(contents)} bytes")
+    except Exception as e:
+        logger.error(f"Failed to read PDF file {file.filename}: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to read PDF file: {str(e)}")
+    
+    try:
+        # Convert PDF bytes to PIL Image objects directly (memory efficient)
+        logger.info(f"Starting PDF to images conversion for {file.filename} with DPI={dpi}")
+        
+        # Convert PDF bytes to images - this returns PIL Image objects
+        images = convert_from_bytes(
+            contents, 
+            dpi=dpi,
+            fmt='PNG'  # Specify format explicitly
+        )
+        
+        logger.info(f"Successfully converted PDF to {len(images)} images")
+        
+        # Convert PIL Images to base64 strings
+        image_b64_list = []
+        for i, image in enumerate(images):
+            try:
+                # Convert PIL Image to bytes
+                img_byte_arr = io.BytesIO()
+                image.save(img_byte_arr, format='PNG')
+                img_byte_arr.seek(0)
+                
+                # Encode to base64
+                b64_string = base64.b64encode(img_byte_arr.getvalue()).decode("utf-8")
+                image_b64_list.append(b64_string)
+                
+                logger.info(f"Processed image {i+1}/{len(images)} from {file.filename}")
+                
+            except Exception as e:
+                logger.error(f"Failed to process image {i+1} from {file.filename}: {str(e)}")
+                raise HTTPException(status_code=500, detail=f"Error processing image {i+1}: {str(e)}")
+        
+        logger.info(f"Successfully converted {file.filename} to {len(image_b64_list)} base64 images")
+        return image_b64_list
+        
+    except Exception as e:
+        logger.error(f"Error processing PDF {file.filename}: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error processing PDF: {str(e)}")
+
+@app.post("/pdf_to_images_with_temp", response_model=List[str])
+async def pdf_to_images_with_temp(
+    file: UploadFile = File(...), 
+    dpi: int = Query(200, description="DPI for image conversion")
+):
+    """
+    Alternative endpoint that uses temporary files - useful for very large PDFs
+    to avoid memory issues
+    """
+    # Validate file type
+    if not file.filename.lower().endswith(".pdf"):
+        raise HTTPException(status_code=400, detail="Only PDF files are allowed")
+    
+    # Read the PDF content into memory
+    try:
+        contents = await file.read()
+        logger.info(f"Successfully read PDF file: {file.filename}, size: {len(contents)} bytes")
+    except Exception as e:
+        logger.error(f"Failed to read PDF file {file.filename}: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to read PDF file: {str(e)}")
     
     try:
         # Create a temporary directory to store the images
         with tempfile.TemporaryDirectory() as temp_dir:
+            logger.info(f"Created temporary directory: {temp_dir}")
+            
             # Convert PDF bytes to image paths (saves to disk to avoid memory issues)
             image_paths = convert_from_bytes(
-                contents,
-                dpi=dpi,
-                output_folder=temp_dir,
-                fmt="png",
+                contents, 
+                dpi=dpi, 
+                output_folder=temp_dir, 
+                fmt="png", 
                 paths_only=True
             )
             
+            logger.info(f"Successfully converted PDF to {len(image_paths)} image files")
+            
             # Convert images to base64 strings from files
             image_b64_list = []
-            for path in image_paths:
-                with open(path, "rb") as img_file:
-                    b64_string = base64.b64encode(img_file.read()).decode("utf-8")
-                    image_b64_list.append(b64_string)
-            
-            return image_b64_list
+            for i, path in enumerate(image_paths):
+                try:
+                    with open(path, "rb") as img_file:
+                        b64_string = base64.b64encode(img_file.read()).decode("utf-8")
+                        image_b64_list.append(b64_string)
+                    
+                    logger.info(f"Processed image file {i+1}/{len(image_paths)}: {os.path.basename(path)}")
+                    
+                except Exception as e:
+                    logger.error(f"Failed to process image file {path}: {str(e)}")
+                    raise HTTPException(status_code=500, detail=f"Error processing image file: {str(e)}")
+        
+        logger.info(f"Successfully converted {file.filename} to {len(image_b64_list)} base64 images using temp files")
+        return image_b64_list
+        
     except Exception as e:
+        logger.error(f"Error processing PDF {file.filename}: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Error processing PDF: {str(e)}")
 
 @app.get("/")
 async def root():
-    return {"message": "Welcome to the PDF to Images API. Use POST /pdf_to_images to convert a PDF to images."}
+    return {
+        "message": "Welcome to the PDF to Images API", 
+        "endpoints": {
+            "pdf_to_images": "Convert PDF to images (memory efficient)",
+            "pdf_to_images_with_temp": "Convert PDF to images using temporary files (for very large PDFs)"
+        },
+        "usage": "Use POST /pdf_to_images to convert a PDF to base64 encoded images"
+    }
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "service": "PDF to Images API"}