store images

app.py

@@ -6,49 +6,35 @@ import io
 import base64
 import logging
 import os
-import json
-import threading
-import time
-import os 
+from dotenv import load_dotenv
+from storage import upload_file_to_bucket
+import datetime
+
+# Load environment variables from .env file
+load_dotenv()
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
 logger = logging.getLogger(__name__)
 
-# Configure Gemini
+# Configure API keys from environment variables
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
 
+# Log API key status (without exposing the actual keys)
+if GEMINI_API_KEY:
+    logger.info("✅ GEMINI_API_KEY loaded successfully")
+else:
+    logger.error("❌ GEMINI_API_KEY not found in environment variables")
+
+if MISTRAL_API_KEY:
+    logger.info("✅ MISTRAL_API_KEY loaded successfully")
+else:
+    logger.error("❌ MISTRAL_API_KEY not found in environment variables")
+
 genai.configure(api_key=GEMINI_API_KEY)
 gemini_model = genai.GenerativeModel('gemini-2.0-flash-exp')
 
-VOTES_FILE = "votes.json"
-votes = []
-votes_lock = threading.Lock()
-
-def load_votes():
-    global votes
-    if os.path.exists(VOTES_FILE):
-        with open(VOTES_FILE, "r") as f:
-            votes = json.load(f)
-    else:
-        votes = []
-
-def save_votes():
-    with votes_lock:
-        with open(VOTES_FILE, "w") as f:
-            json.dump(votes, f, indent=2)
-
-def periodic_vote_dump(interval=60):
-    def run():
-        while True:
-            save_votes()
-            time.sleep(interval)
-    t = threading.Thread(target=run, daemon=True)
-    t.start()
-
-load_votes()
-periodic_vote_dump(60)
 
 def get_default_username(profile: gr.OAuthProfile | None) -> str:
     """
@@ -122,9 +108,37 @@ def process_image(image):
         return "Please upload an image.", "Please upload an image."
     
     try:
+        # Save the PIL image to a temporary file
+        temp_filename = f"temp_image_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
+        image.save(temp_filename)
+        
+        # Upload the temporary file to Supabase storage
+        logger.info(f"📤 Uploading image to Supabase storage: {temp_filename}")
+        upload_result = upload_file_to_bucket(
+            file_path=temp_filename,
+            bucket_name="images",
+            storage_path=f"ocr_images/{temp_filename}",
+            file_options={"cache-control": "3600", "upsert": "false"}
+        )
+        
+        if upload_result["success"]:
+            logger.info(f"✅ Image uploaded successfully: {upload_result['storage_path']}")
+            logger.info(f"🔗 Public URL: {upload_result['public_url']}")
+        else:
+            logger.error(f"❌ Image upload failed: {upload_result['error']}")
+        
+        # Clean up temporary file
+        try:
+            os.remove(temp_filename)
+            logger.info(f"🗑️ Cleaned up temporary file: {temp_filename}")
+        except Exception as e:
+            logger.warning(f"⚠️ Could not remove temporary file {temp_filename}: {e}")
+        
+        # Process OCR
         gemini_result = gemini_ocr(image)
         mistral_result = mistral_ocr(image)
         return gemini_result, mistral_result
+        
     except Exception as e:
         logger.error(f"Error processing image: {e}")
         return f"Error processing image: {e}", f"Error processing image: {e}"
@@ -184,13 +198,6 @@ with gr.Blocks(title="OCR Comparison: Gemini vs Mistral", css="""
         if not username:
             gr.Info("Please login with your Hugging Face account to vote.")
             return
-        image_id = get_image_id(image)
-        with votes_lock:
-            for v in votes:
-                if v["image_id"] == image_id and v["username"] == username:
-                    gr.Info("You already voted for this image.")
-                    return
-            votes.append({"image_id": image_id, "username": username, "winner": "gemini"})
         info_message = (
             f"<p>You voted for <strong style='color:green;'>👈 Gemini OCR</strong>.</p>"
             f"<p><span style='color:green;'>👈 Gemini OCR</span> - "
@@ -202,13 +209,6 @@ with gr.Blocks(title="OCR Comparison: Gemini vs Mistral", css="""
         if not username:
             gr.Info("Please login with your Hugging Face account to vote.")
             return
-        image_id = get_image_id(image)
-        with votes_lock:
-            for v in votes:
-                if v["image_id"] == image_id and v["username"] == username:
-                    gr.Info("You already voted for this image.")
-                    return
-            votes.append({"image_id": image_id, "username": username, "winner": "mistral"})
         info_message = (
             f"<p>You voted for <strong style='color:blue;'>👉 Mistral OCR</strong>.</p>"
             f"<p><span style='color:green;'>👈 Gemini OCR</span> - "

storage.py

@@ -0,0 +1,212 @@
+"""Supabase storage helper for uploading files.
+
+This module provides functions to upload files to Supabase storage
+using HTTP requests, avoiding the dependency issues with the supabase client library.
+"""
+import os
+import requests
+import logging
+from typing import Optional, Dict, Any
+from pathlib import Path
+
+# Import Supabase credentials from environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+
+if not SUPABASE_URL or not SUPABASE_KEY:
+    raise ImportError("Could not load Supabase credentials from environment variables")
+
+logger = logging.getLogger(__name__)
+
+# Supabase storage API configuration
+STORAGE_BASE_URL = f"{SUPABASE_URL}/storage/v1"
+HEADERS = {
+    "apikey": SUPABASE_KEY,
+    "Authorization": f"Bearer {SUPABASE_KEY}",
+    "Content-Type": "application/json"
+}
+
+def upload_file_to_bucket(
+    file_path: str,
+    bucket_name: str = "images",
+    storage_path: Optional[str] = None,
+    file_options: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """
+    Upload a file to Supabase storage bucket.
+    
+    Args:
+        file_path: Local path to the file to upload
+        bucket_name: Name of the storage bucket (default: "images")
+        storage_path: Path in the bucket where to store the file (default: filename)
+        file_options: Optional file options like cache-control, upsert, etc.
+    
+    Returns:
+        Dictionary with upload result information
+    """
+    try:
+        # Check if file exists
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+        
+        # Get file info
+        file_path_obj = Path(file_path)
+        file_name = file_path_obj.name
+        
+        # Use provided storage_path or default to filename
+        if storage_path is None:
+            storage_path = file_name
+        
+        # Prepare upload URL
+        upload_url = f"{STORAGE_BASE_URL}/object/{bucket_name}/{storage_path}"
+        
+        # Prepare headers for file upload
+        upload_headers = {
+            "apikey": SUPABASE_KEY,
+            "Authorization": f"Bearer {SUPABASE_KEY}"
+        }
+        
+        # Add file options if provided
+        if file_options:
+            for key, value in file_options.items():
+                upload_headers[f"x-upsert"] = str(value).lower() if key == "upsert" else str(value)
+        
+        # Read and upload file
+        with open(file_path, "rb") as f:
+            response = requests.post(
+                upload_url,
+                headers=upload_headers,
+                data=f
+            )
+        
+        if response.status_code == 200:
+            result = response.json()
+            logger.info(f"✅ File uploaded successfully: {file_name}")
+            logger.info(f"📁 Storage path: {storage_path}")
+            logger.info(f"🔗 Public URL: {result.get('publicUrl', 'N/A')}")
+            return {
+                "success": True,
+                "file_name": file_name,
+                "storage_path": storage_path,
+                "public_url": result.get('publicUrl'),
+                "response": result
+            }
+        else:
+            logger.error(f"❌ Upload failed with status {response.status_code}")
+            logger.error(f"Response: {response.text}")
+            return {
+                "success": False,
+                "error": f"Upload failed: {response.status_code}",
+                "response": response.text
+            }
+            
+    except Exception as e:
+        logger.error(f"❌ Error uploading file: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+def get_file_url(bucket_name: str, file_path: str) -> str:
+    """
+    Get the public URL for a file in Supabase storage.
+    
+    Args:
+        bucket_name: Name of the storage bucket
+        file_path: Path to the file in the bucket
+    
+    Returns:
+        Public URL for the file
+    """
+    return f"{SUPABASE_URL}/storage/v1/object/public/{bucket_name}/{file_path}"
+
+def list_bucket_files(bucket_name: str = "images") -> Dict[str, Any]:
+    """
+    List all files in a storage bucket.
+    
+    Args:
+        bucket_name: Name of the storage bucket
+    
+    Returns:
+        Dictionary with list of files
+    """
+    try:
+        list_url = f"{STORAGE_BASE_URL}/object/list/{bucket_name}"
+        response = requests.get(list_url, headers=HEADERS)
+        
+        if response.status_code == 200:
+            result = response.json()
+            logger.info(f"✅ Listed {len(result)} files in bucket '{bucket_name}'")
+            return {
+                "success": True,
+                "files": result
+            }
+        else:
+            logger.error(f"❌ Failed to list files: {response.status_code}")
+            return {
+                "success": False,
+                "error": f"Failed to list files: {response.status_code}"
+            }
+    except Exception as e:
+        logger.error(f"❌ Error listing files: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+def test_upload_image_png():
+    """Test function to upload Image.png to the images bucket."""
+    try:
+        logger.info("🚀 Testing file upload to Supabase storage...")
+        
+        # First, test if we can list files (this tests basic connectivity)
+        logger.info("📋 Testing bucket connectivity...")
+        list_result = list_bucket_files("images")
+        if list_result["success"]:
+            logger.info(f"✅ Bucket connectivity successful! Found {len(list_result['files'])} files")
+        else:
+            logger.warning(f"⚠️ Bucket connectivity issue: {list_result['error']}")
+        
+        # Test upload
+        logger.info("📤 Testing file upload...")
+        result = upload_file_to_bucket(
+            file_path="Image.png",
+            bucket_name="images",
+            storage_path="test/Image.png",
+            file_options={"cache-control": "3600", "upsert": "false"}
+        )
+        
+        if result["success"]:
+            logger.info("✅ Upload test successful!")
+            logger.info(f"📁 File uploaded to: {result['storage_path']}")
+            logger.info(f"🔗 Public URL: {result['public_url']}")
+            return True
+        else:
+            logger.error(f"❌ Upload test failed: {result['error']}")
+            
+            # Provide helpful error information
+            if "row-level security policy" in result.get('response', ''):
+                logger.error("🔧 This is a storage permissions issue.")
+                logger.error("📋 To fix this, you need to configure your Supabase storage bucket:")
+                logger.error("""
+                1. Go to your Supabase dashboard
+                2. Navigate to Storage > Policies
+                3. For the 'images' bucket, add a policy like:
+                
+                CREATE POLICY "Allow public uploads" ON storage.objects
+                FOR INSERT WITH CHECK (bucket_id = 'images');
+                
+                CREATE POLICY "Allow public reads" ON storage.objects
+                FOR SELECT USING (bucket_id = 'images');
+                
+                Or make the bucket public in Storage > Settings
+                """)
+            
+            return False
+            
+    except Exception as e:
+        logger.error(f"❌ Upload test error: {e}")
+        return False