Supbase removed

app.py

@@ -13,21 +13,9 @@ import json
 import base64
 import os
 import uuid
-import requests
-from urllib.parse import urlparse
 
 from huggingface_hub import hf_hub_download
 
-# Try to import Supabase (optional - for embedding storage/retrieval)
-try:
-    from supabase import create_client, Client
-    SUPABASE_AVAILABLE = True
-    SupabaseClientType = Client
-except ImportError:
-    SUPABASE_AVAILABLE = False
-    SupabaseClientType = None  # Type placeholder when Supabase not available
-    print("⚠️  Supabase not available. Embedding storage/retrieval will be disabled.")
-
 # Import SAM components
 from segment_anything import sam_model_registry, SamPredictor, SamAutomaticMaskGenerator
 
@@ -73,7 +61,7 @@ print(f"Loading SAM model ({MODEL_TYPE}) from downloaded checkpoint...")
 try:
     # Ensure we always load onto CPU when no GPU is available
     torch.load = patched_torch_load
-    sam = sam_model_registry[MODEL_TYPE](checkpoint=MODEL_CHECKPOINT)
+sam = sam_model_registry[MODEL_TYPE](checkpoint=MODEL_CHECKPOINT)
 finally:
     torch.load = original_torch_load
 
@@ -102,126 +90,11 @@ mask_generator = SamAutomaticMaskGenerator(
 print("✓ SamAutomaticMaskGenerator initialized for automatic segmentation")
 print("✓ SAM model loaded successfully from HuggingFace Hub!")
 
-# -----------------------------------------------------------------------------
-# Supabase setup (for embedding storage/retrieval)
-# -----------------------------------------------------------------------------
-supabase = None  # Will be set to Supabase Client if available
-EMBED_BUCKET = "embeddings"
-EMBED_TABLE = "embeddings2"
-
-if SUPABASE_AVAILABLE:
-    try:
-        SUPABASE_URL = os.getenv("SUPABASE_URL") or os.getenv("REACT_APP_SUPABASE_URL")
-        SUPABASE_KEY = os.getenv("SUPABASE_KEY") or os.getenv("REACT_APP_SUPABASE_ANON_KEY")
-        
-        if SUPABASE_URL and SUPABASE_KEY:
-            supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
-            print("✓ Supabase client initialized for embedding storage/retrieval")
-        else:
-            print("⚠️  Supabase credentials not found in environment variables")
-            print("   Set SUPABASE_URL and SUPABASE_KEY (or REACT_APP_SUPABASE_URL/REACT_APP_SUPABASE_ANON_KEY)")
-    except Exception as e:
-        print(f"⚠️  Failed to initialize Supabase: {e}")
-        supabase = None
-else:
-    print("⚠️  Supabase not available - embedding features disabled")
-
 
 # =============================================================================
-# HELPER FUNCTIONS FOR EMBEDDINGS
+# HELPER FUNCTIONS FOR EMBEDDINGS (STATELESS)
 # =============================================================================
 
-def save_embedding_to_supabase(image_id: str, embedding_tensor: torch.Tensor) -> bool:
-    """
-    Save SAM image embedding to Supabase (embeddings2 table + embeddings bucket)
-    
-    Args:
-        image_id: Image ID from database
-        embedding_tensor: Embedding tensor from sam.image_encoder (shape: [1, C, H, W])
-        
-    Returns:
-        True if successful, False otherwise
-    """
-    if not supabase:
-        return False
-    
-    try:
-        # Convert tensor to numpy array (same format as old backend)
-        arr = embedding_tensor.squeeze(0).cpu().numpy().astype(np.float32)
-        
-        # Save to bytes buffer
-        buf = io.BytesIO()
-        np.save(buf, arr)
-        buf.seek(0)
-        
-        # Upload to Supabase storage
-        path = f"{image_id}/{uuid.uuid4().hex}.npy"
-        supabase.storage.from_(EMBED_BUCKET).upload(path, buf.read())
-        
-        # Save metadata to embeddings2 table
-        supabase.table(EMBED_TABLE).insert({
-            'image_id': image_id,
-            'file_path': path
-        }).execute()
-        
-        print(f"✓ Saved embedding for image_id={image_id} to Supabase")
-        return True
-        
-    except Exception as e:
-        print(f"✗ Error saving embedding to Supabase: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def load_embedding_from_supabase(image_id: str) -> torch.Tensor:
-    """
-    Load SAM image embedding from Supabase
-    
-    Args:
-        image_id: Image ID from database
-        
-    Returns:
-        Embedding tensor (shape: [1, C, H, W]) or None if not found
-    """
-    if not supabase:
-        return None
-    
-    try:
-        # Query embeddings2 table
-        response = supabase.table(EMBED_TABLE).select('*').eq('image_id', image_id).execute()
-        
-        if not response.data:
-            print(f"No embedding found for image_id={image_id}")
-            return None
-        
-        embed_record = response.data[0]
-        file_path = embed_record['file_path']
-        
-        # Get signed URL for the embedding file
-        signed = supabase.storage.from_(EMBED_BUCKET).create_signed_url(file_path, 3600)
-        signed_url = signed["signedUrl"]
-        
-        # Download embedding file
-        r = requests.get(signed_url)
-        r.raise_for_status()
-        
-        # Load numpy array
-        embedding_array = np.load(io.BytesIO(r.content))
-        
-        # Convert to tensor and add batch dimension
-        embedding_tensor = torch.from_numpy(embedding_array).unsqueeze(0).to(device)
-        
-        print(f"✓ Loaded embedding for image_id={image_id} from Supabase")
-        return embedding_tensor
-        
-    except Exception as e:
-        print(f"✗ Error loading embedding from Supabase: {e}")
-        import traceback
-        traceback.print_exc()
-        return None
-
-
 def set_predictor_features_from_embedding(embedding_tensor: torch.Tensor, image_shape: tuple):
     """
     Set SamPredictor's internal features using precomputed embedding
@@ -244,53 +117,44 @@ def set_predictor_features_from_embedding(embedding_tensor: torch.Tensor, image_
 
 def encode_image(image, request_json):
     """
-    Encode image using SAM image encoder and save embedding to Supabase
-    
+    Encode image using SAM image encoder and return embedding to the client.
+
+    This is now a stateless API: it does NOT talk to Supabase. The caller
+    (your backend) is responsible for storing the embedding if desired.
+
     Args:
         image: PIL Image
-        request_json: JSON string with format:
+        request_json: JSON string with optional fields:
             {
-                "image_id": "uuid-string"  # Required: image ID from database
+                "image_id": "uuid-string"  # Optional: image ID from your DB
             }
-    
+
     Returns:
         JSON string:
         {
             "success": true/false,
-            "message": "Embedding saved successfully" or error message,
-            "image_id": "uuid-string"
+            "image_id": "uuid-string" or null,
+            "embedding_npy_base64": "...",   # base64-encoded .npy of [C,H,W]
+            "embedding_shape": [1, C, H, W]
         }
     """
     try:
-        # Parse input
-        data = json.loads(request_json)
+        # Parse input (image_id is optional and just echoed back)
+        data = json.loads(request_json) if request_json else {}
         image_id = data.get("image_id")
         
-        if not image_id:
-            return json.dumps({
-                'success': False,
-                'error': 'image_id is required'
-            })
-        
-        if not supabase:
-            return json.dumps({
-                'success': False,
-                'error': 'Supabase not configured. Set SUPABASE_URL and SUPABASE_KEY environment variables.'
-            })
-        
         # Convert PIL to numpy
         image_array = np.array(image)
         H, W = image_array.shape[:2]
         
         # Resize image to SAM's expected input size (1024x1024)
-        # SAM expects images to be resized before encoding
         from skimage import transform
         img_resized = transform.resize(
-            image_array, 
-            (1024, 1024), 
-            order=3, 
-            preserve_range=True, 
-            anti_aliasing=True
+            image_array,
+            (1024, 1024),
+            order=3,
+            preserve_range=True,
+            anti_aliasing=True,
         ).astype(np.uint8)
         
         # Normalize image (SAM expects normalized input)
@@ -299,36 +163,45 @@ def encode_image(image, request_json):
         )
         
         # Convert to tensor and add batch dimension
-        tensor = torch.tensor(img_norm).float().permute(2, 0, 1).unsqueeze(0).to(device)
+        tensor = (
+            torch.tensor(img_norm)
+            .float()
+            .permute(2, 0, 1)
+            .unsqueeze(0)
+            .to(device)
+        )
         
         # Encode image using SAM image encoder
-        print(f"Encoding image {image_id} (size: {W}x{H})...")
+        print(f"Encoding image (image_id={image_id}) original size: {W}x{H} -> 1024x1024")
         with torch.no_grad():
             embedding = sam.image_encoder(tensor)
-        
-        # Save embedding to Supabase
-        success = save_embedding_to_supabase(image_id, embedding)
-        
-        if success:
-            return json.dumps({
-                'success': True,
-                'message': f'Embedding saved successfully for image_id={image_id}',
-                'image_id': image_id,
-                'embedding_shape': list(embedding.shape)
-            })
-        else:
-            return json.dumps({
-                'success': False,
-                'error': 'Failed to save embedding to Supabase'
-            })
-        
+
+        # Convert embedding to numpy [C, Hf, Wf]
+        arr = embedding.squeeze(0).cpu().numpy().astype(np.float32)
+
+        # Serialize as .npy in memory and base64-encode it
+        buf = io.BytesIO()
+        np.save(buf, arr)
+        buf.seek(0)
+        embedding_b64 = base64.b64encode(buf.read()).decode("utf-8")
+
+        return json.dumps(
+            {
+                "success": True,
+                "image_id": image_id,
+                "embedding_npy_base64": embedding_b64,
+                "embedding_shape": list(embedding.shape),
+            }
+        )
     except Exception as e:
         import traceback
-        return json.dumps({
-            'success': False,
-            'error': str(e),
-            'traceback': traceback.format_exc()
-        })
+        return json.dumps(
+            {
+                "success": False,
+                "error": str(e),
+                "traceback": traceback.format_exc(),
+            }
+        )
 
 
 def segment_points(image, request_json):
@@ -369,20 +242,8 @@ def segment_points(image, request_json):
         image_array = np.array(image)
         H, W = image_array.shape[:2]
         
-        # Try to use precomputed embedding if image_id is provided
-        if image_id and supabase:
-            embedding_tensor = load_embedding_from_supabase(image_id)
-            if embedding_tensor is not None:
-                # Use precomputed embedding
-                set_predictor_features_from_embedding(embedding_tensor, (H, W))
-                print(f"Using precomputed embedding for image_id={image_id}")
-            else:
-                # Fall back to computing embedding from image
-                print(f"Embedding not found for image_id={image_id}, computing from image...")
-                predictor.set_image(image_array)
-        else:
-            # No image_id provided or Supabase not available - compute embedding from image
-            predictor.set_image(image_array)
+        # For now, always compute embedding from image (stateless API)
+        predictor.set_image(image_array)
         
         # Process each point individually (like backend does)
         box_size = 20  # Small box size for point-based segmentation
@@ -481,20 +342,9 @@ def segment_box(image, request_json):
         
         # Convert PIL to numpy
         image_array = np.array(image)
-        H, W = image_array.shape[:2]
         
-        # Try to use precomputed embedding if image_id is provided
-        image_id = data.get("image_id")
-        if image_id and supabase:
-            embedding_tensor = load_embedding_from_supabase(image_id)
-            if embedding_tensor is not None:
-                set_predictor_features_from_embedding(embedding_tensor, (H, W))
-                print(f"Using precomputed embedding for image_id={image_id}")
-            else:
-                print(f"Embedding not found for image_id={image_id}, computing from image...")
-                predictor.set_image(image_array)
-        else:
-            predictor.set_image(image_array)
+        # Stateless: always compute embedding from image
+        predictor.set_image(image_array)
         
         # Run prediction with box
         masks, scores, logits = predictor.predict(
@@ -564,20 +414,9 @@ def segment_multiple_boxes(image, request_json):
         
         # Convert PIL to numpy
         image_array = np.array(image)
-        H, W = image_array.shape[:2]
         
-        # Try to use precomputed embedding if image_id is provided
-        image_id = data.get("image_id")
-        if image_id and supabase:
-            embedding_tensor = load_embedding_from_supabase(image_id)
-            if embedding_tensor is not None:
-                set_predictor_features_from_embedding(embedding_tensor, (H, W))
-                print(f"Using precomputed embedding for image_id={image_id}")
-            else:
-                print(f"Embedding not found for image_id={image_id}, computing from image...")
-                predictor.set_image(image_array)
-        else:
-            predictor.set_image(image_array)
+        # Stateless: always compute embedding from image
+        predictor.set_image(image_array)
         
         print(f"Processing {len(bboxes)} boxes for segmentation")
         

requirements.txt

@@ -7,5 +7,4 @@ opencv-python>=4.8.0
 scikit-image>=0.21.0
 segment-anything @ git+https://github.com/facebookresearch/segment-anything.git
 huggingface_hub>=0.23.0
-supabase-py>=2.0.0
 requests>=2.31.0