Allow admin dashboard to process images properly

api/product_routes.py

@@ -2,9 +2,7 @@ from fastapi import APIRouter, File, UploadFile, HTTPException, Form
 from utils.image_processing import read_image_file, process_product_image
 from product_detector.detector import ObjectDetector
 from config.settings import MODEL_ONNX_PATH, CLASS_NAMES, INPUT_SIZE
-from typing import Optional
-from db.supabase_client import SupabaseClient
-import uuid
+from utils.image_processing import process_and_store_product_image
 
 # Initialize the detector
 detector = ObjectDetector(
@@ -15,10 +13,12 @@ detector = ObjectDetector(
 
 router = APIRouter(tags=["Product Detection"])
 
+
 @router.options("/detect-product")
 async def detect_options():
     return {"Allow": "POST"}
 
+
 @router.post("/detect-product")
 async def detect_objects(file: UploadFile = File(...)):
     try:
@@ -35,125 +35,68 @@ async def detect_objects(file: UploadFile = File(...)):
     except Exception as e:
         raise HTTPException(500, f"Processing error: {str(e)}")
 
+
 @router.post("/process-image")
 async def process_image(
-    file: UploadFile = File(...),
-    remove_bg: bool = Form(True),
-    upscale: bool = Form(True),
-    scale_factor: int = Form(2),
-    process_order: str = Form("remove_first")
+        file: UploadFile = File(...),
+        remove_bg: bool = Form(True),
+        upscale: bool = Form(True),
+        scale_factor: int = Form(2),
+        process_order: str = Form("remove_first")
 ):
     """
     Process product images by removing background and/or upscaling
-    
-    - remove_bg: Whether to remove the white background
-    - upscale: Whether to upscale the image
-    - scale_factor: Scale factor for upscaling (2, 3, or 4)
-    - process_order: Order of operations ('remove_first' or 'upscale_first')
     """
     try:
         # Validate inputs
         if scale_factor not in [2, 3, 4]:
             raise HTTPException(400, "Scale factor must be 2, 3, or 4")
-        
+
         if process_order not in ["remove_first", "upscale_first"]:
             raise HTTPException(400, "Process order must be 'remove_first' or 'upscale_first'")
-        
+
         if not file.content_type.startswith("image/"):
             raise HTTPException(400, "File must be an image")
-        
-        # Process the image
-        processed_image, filename = await process_product_image(
-            file, 
+
+        # Use the combined processing and storage function
+        result = await process_and_store_product_image(
+            file,
             remove_bg=remove_bg,
             upscale=upscale,
             scale_factor=scale_factor,
             process_order=process_order
         )
-        
-        # Generate a unique ID for the image
-        image_id = str(uuid.uuid4())
-        image_path = f"{image_id}_{filename}"
-        
-        # Upload the processed image to Supabase Storage
-        supabase.storage.from_("product-images").upload(
-            file=processed_image,
-            path=image_path,
-            file_options={"content-type": "image/png", "upsert": "true"}
-        )
-        
-        # Get the public URL for the uploaded image
-        image_url = supabase.storage.from_("product-images").get_public_url(image_path)
-        
-        return {
-            "status": "success",
-            "message": "Image processed successfully",
-            "image_url": image_url,
-            "image_path": image_path,
-            "processing": {
-                "background_removed": remove_bg,
-                "upscaled": upscale,
-                "scale_factor": scale_factor if upscale else None,
-                "process_order": process_order
-            }
-        }
-        
+
+        return result
     except HTTPException:
         raise
     except Exception as e:
         raise HTTPException(500, f"Image processing error: {str(e)}")
-    
-    
+
+
 @router.post("/process-product-image")
 async def process_product_image_endpoint(
-    file: UploadFile = File(...),
-    remove_bg: bool = Form(True),
-    upscale: bool = Form(True),
-    scale_factor: int = Form(2),
-    process_order: str = Form("remove_first"),
-    product_id: str = Form(None)
+        file: UploadFile = File(...),
+        remove_bg: bool = Form(True),
+        upscale: bool = Form(True),
+        scale_factor: int = Form(2),
+        process_order: str = Form("remove_first"),
+        product_id: str = Form(None)
 ):
     """
-    Process a product image by removing background and upscaling,
-    then save to Supabase Storage
+    Process a product image and update the product record
     """
     try:
-        # Process the image
-        processed_image, filename = await process_product_image(
-            file, 
+        # Use the combined processing, storage and database function
+        result = await process_and_store_product_image(
+            file,
             remove_bg=remove_bg,
             upscale=upscale,
             scale_factor=scale_factor,
-            process_order=process_order
-        )
-        
-        # Generate a unique ID for the image
-        image_id = str(uuid.uuid4())
-        image_path = f"{image_id}_{filename}"
-        
-        # Upload the processed image to Supabase Storage
-        supabase.storage.from_("product-images").upload(
-            file=processed_image,
-            path=image_path,
-            file_options={"content-type": "image/png", "upsert": "true"}
+            process_order=process_order,
+            product_id=product_id
         )
-        
-        # Get the public URL for the uploaded image
-        image_url = supabase.storage.from_("product-images").get_public_url(image_path)
-        
-        # If product_id is provided, update the product record
-        if product_id:
-            # Update product_image column in the database
-            result = supabase.table("products").update({
-                "product_image": image_url
-            }).eq("id", product_id).execute()
-        
-        return {
-            "status": "success",
-            "message": "Image processed successfully",
-            "image_url": image_url,
-            "image_path": image_path
-        }
-        
+
+        return result
     except Exception as e:
         raise HTTPException(500, f"Image processing error: {str(e)}")

db/receipt_repository.py

@@ -2,7 +2,8 @@ import uuid
 import json
 from datetime import datetime
 from typing import Optional, Dict, Any
-from .supabase_client import SupabaseClient
+from supabase_client import SupabaseClient
+
 
 class ReceiptRepository:
     def __init__(self):

db/scrape_repository.py

@@ -1,6 +1,7 @@
 from typing import Dict, Any, List
 from datetime import datetime
-from .supabase_client import SupabaseClient
+from supabase_client import SupabaseClient
+
 
 class PromoProductRepository:
     def __init__(self):
@@ -23,7 +24,7 @@ class PromoProductRepository:
                 store = product.get("store")
                 name = product.get("name")
                 
-                formatted_product = {
+                formatted_promo_product = {
                     "store": store,
                     "picture_id": product.get("pictureId"),
                     "name": name,
@@ -46,13 +47,15 @@ class PromoProductRepository:
                         # Product exists, update it
                         record_id = result.data[0]["id"]
                         self.supabase.table("promo_products") \
-                            .update(formatted_product) \
+                            .update(formatted_promo_product) \
                             .eq("id", record_id) \
                             .execute()
+
+
                     else:
                         # Product doesn't exist, insert it
                         self.supabase.table("promo_products") \
-                            .insert(formatted_product) \
+                            .insert(formatted_promo_product) \
                             .execute()
                     
                     successfully_upserted += 1

utils/image_processing.py

@@ -1,12 +1,15 @@
 import numpy as np
 import cv2
 from fastapi import UploadFile, HTTPException
-from PIL import Image
-import io
 from rembg import remove
 import time
 import uuid
 from typing import Tuple, Optional
+from db.supabase_client import SupabaseClient
+
+# Initialize Supabase client
+supabase = SupabaseClient().get_client()
+
 
 async def read_image_file(file: UploadFile) -> np.ndarray:
     """Read and process an image file from FastAPI UploadFile"""
@@ -21,14 +24,20 @@ async def read_image_file(file: UploadFile) -> np.ndarray:
         
     return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
 
+
 def remove_background(image_bytes: bytes) -> bytes:
     """Remove white background from image using rembg"""
     try:
-        return remove(image_bytes)
+        return remove(image_bytes,
+                      alpha_matting=True,
+                      alpha_matting_background_threshold=5,
+                      alpha_matting_foreground_threshold=220,
+                      alpha_matting_erode_size=5)
     except Exception as e:
         print(f"Error removing background: {str(e)}")
         raise Exception(f"Background removal error: {str(e)}")
 
+
 def upscale_image(image_bytes: bytes, scale_factor: int = 2) -> bytes:
     """Upscale image using OpenCV"""
     try:
@@ -72,6 +81,7 @@ def upscale_image(image_bytes: bytes, scale_factor: int = 2) -> bytes:
         print(f"Error upscaling image: {str(e)}")
         raise Exception(f"Image upscaling error: {str(e)}")
 
+
 async def process_product_image(
     file: UploadFile, 
     remove_bg: bool = True, 
@@ -107,4 +117,102 @@ async def process_product_image(
     # Create descriptive filename with processing info
     processed_filename = f"{base_name}_{'nobg' if remove_bg else ''}_{'upx' + str(scale_factor) if upscale else ''}_{timestamp}.{extension}"
     
-    return processed_content, processed_filename
+    return processed_content, processed_filename
+
+
+async def upload_processed_image(
+        processed_image: bytes,
+        filename: str,
+        bucket: str = "product-images"
+) -> Tuple[str, str]:
+    """
+    Upload a processed image to Supabase Storage
+
+    Returns:
+        Tuple[str, str]: (image_path, image_url)
+    """
+    # Generate a unique ID for the image
+    image_id = str(uuid.uuid4())
+    image_path = f"{image_id}_{filename}"
+
+    # Upload the processed image to Supabase Storage
+    supabase.storage.from_(bucket).upload(
+        file=processed_image,
+        path=image_path,
+        file_options={"content-type": "image/png", "upsert": "true"}
+    )
+
+    # Get the public URL for the uploaded image
+    image_url = supabase.storage.from_(bucket).get_public_url(image_path)
+
+    return image_path, image_url
+
+async def update_product_image(product_id: str, image_url: str) -> dict[str, any]:
+    """
+    Update the product_image field for a product
+
+    Returns:
+        Dict[str, Any]: The updated product data
+    """
+    if not product_id:
+        raise ValueError("Product ID is required")
+
+    result = supabase.table("products").update({
+        "product_image": image_url
+    }).eq("id", product_id).execute()
+
+    if not result.data:
+        raise Exception(f"Failed to update product {product_id}")
+
+    return result.data[0]
+
+async def process_and_store_product_image(
+        file: UploadFile,
+        remove_bg: bool = True,
+        upscale: bool = True,
+        scale_factor: int = 2,
+        process_order: str = "remove_first",
+        product_id: Optional[str] = None
+) -> dict[str, any]:
+    """
+    Complete workflow for processing a product image and storing it
+
+    This function:
+    1. Processes the image (remove background, upscale)
+    2. Uploads it to storage
+    3. Updates the product record if product_id is provided
+
+    Returns:
+        Dict[str, Any]: Result with status, urls, and processing info
+    """
+    # Process the image
+    processed_image, filename = await process_product_image(
+        file,
+        remove_bg=remove_bg,
+        upscale=upscale,
+        scale_factor=scale_factor,
+        process_order=process_order
+    )
+
+    # Upload to storage
+    image_path, image_url = await upload_processed_image(processed_image, filename)
+
+    # Update product record if needed
+    product_data = None
+    if product_id:
+        product_data = await update_product_image(product_id, image_url)
+
+    # Return comprehensive result
+    return {
+        "status": "success",
+        "message": "Image processed successfully",
+        "image_url": image_url,
+        "image_path": image_path,
+        "product_data": product_data,
+        "processing": {
+            "background_removed": remove_bg,
+            "upscaled": upscale,
+            "scale_factor": scale_factor if upscale else None,
+            "process_order": process_order
+        }
+    }