Auto deploy Embeddings API

.gitattributes

@@ -0,0 +1,4 @@
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,28 @@
+# Use official lightweight Python image
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    python3-dev \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy app code
+COPY . .
+
+# Expose port
+EXPOSE 8000
+
+# Start FastAPI server
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,8 @@
+---
+title: Fourwalls Embedding API
+emoji: 🏠
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+pinned: false
+---

main.py

@@ -0,0 +1,150 @@
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+import io
+import numpy as np
+from PIL import Image
+import tensorflow as tf
+import uvicorn
+from supabase_client import supabase
+from models import create_models
+
+# Constants
+IMG_SIZE = 224
+
+# Load models
+base_model = tf.keras.applications.MobileNetV2(
+  input_shape=(IMG_SIZE, IMG_SIZE, 3),
+  include_top=False,
+  weights="imagenet"
+)
+base_model.trainable = False
+
+# Create the base and top models
+base_model, top_model = create_models(IMG_SIZE)
+
+
+app = FastAPI()
+
+def preprocess_image(image_bytes):
+  """Preprocess the uploaded image for MobileNetV2"""
+  image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+  image = image.resize((IMG_SIZE, IMG_SIZE))
+  array = np.array(image).astype("float32") / 255.0
+  return np.expand_dims(array, axis=0)
+
+@app.get("/")
+def read_root():
+  return {"status": "ok"}
+
+# Helper to download image from Supabase Storage using supabase-py
+def download_image_from_supabase(bucket_id, file_path):
+    resp = supabase.storage.from_(bucket_id).download(file_path)
+    if not resp:
+        raise Exception(f"Failed to download image from {bucket_id}/{file_path}")
+    return resp
+
+# Helper to insert record into property_images table using supabase-py
+def insert_property_image(property_id, aspect, embedding, confidence, image_url):
+    try:
+      data = {
+          "property_id": property_id,
+          "aspect": aspect,
+          "embedding": embedding,
+          "confidence": confidence,
+          "url": image_url
+      }
+      resp = supabase.table("property_images").insert(data).execute()
+      return resp.data
+    except Exception as e:
+        raise Exception(f"Failed to insert property image: {str(e)}")
+    
+
+@app.post("/on-upload")
+async def embed_image(request: Request):
+  """ Endpoint to embed images after upload. Triggered by Supabase Storage webhook.
+  """
+  try:
+    data = await request.json()
+    print("Received webhook data:", data)
+    record = data.get("record")
+    if not record:
+      return JSONResponse(status_code=400, content={"error": "Missing record in webhook data"})
+
+    bucket_id = record.get("bucket_id")
+    file_path = record.get("name")
+    if not bucket_id or not file_path:
+      return JSONResponse(status_code=400, content={"error": "Missing bucket_id or file_path."})
+
+    # Only process if the image is a property image
+    if not bucket_id == "property-images":
+      print(f"Skipping non-property image: {file_path}")
+      return JSONResponse({"status": "skipped", "reason": "not a property image"})
+
+    # Download image from Supabase Storage
+    image_bytes = download_image_from_supabase(bucket_id, file_path)
+    print(f"Downloaded image: {file_path} ({len(image_bytes)} bytes)")
+
+    # Preprocess and embed
+    img_tensor = preprocess_image(image_bytes)
+    feature_map = base_model(img_tensor, training=False)
+    prediction = top_model(feature_map, training=False)
+    pooled_embedding = tf.keras.layers.GlobalAveragePooling2D()(feature_map)
+    embedding_vector = pooled_embedding.numpy()[0].tolist()
+    aspect = "exterior" if prediction.numpy()[0][0] > 0.5 else "interior"
+    confidence = float(prediction.numpy()[0][0])
+
+    # Extract property_id from file_path (after 'property_image/' and before the next slash)
+    property_id = file_path.split("/")[0]
+
+    # Get public URL for the image
+    public_url = supabase.storage.from_(bucket_id).get_public_url(file_path)
+
+    confidence = 1 - confidence if aspect == "interior" else confidence
+
+    # Insert into property_images table
+    insert_property_image(property_id, aspect, embedding_vector, confidence, public_url)
+
+    return JSONResponse({"status": "ok"})
+  except Exception as e:
+    print("Error in /embed:", str(e))
+    return JSONResponse(status_code=500, content={"error": str(e)})
+
+@app.post('/on-delete')
+async def on_delete(request: Request):
+  """ Endpoint to handle image deletions. Triggered by Supabase Storage webhook.
+  """
+  try:
+    data = await request.json()
+    print("Received delete webhook data:", data)
+    record = data.get("record")
+    if not record:
+      return JSONResponse(status_code=400, content={"error": "Missing record in webhook data"})
+
+    bucket_id = record.get("bucket_id")
+    file_path = record.get("name")
+    if not bucket_id or not file_path:
+      return JSONResponse(status_code=400, content={"error": "Missing bucket_id or file_path."})
+
+    # Only process if the image is a property image
+    if not bucket_id == "property-images":
+      print(f"Skipping non-property image: {file_path}")
+      return JSONResponse({"status": "skipped", "reason": "not a property image"})
+
+    # Create image url
+    public_url = supabase.storage.from_(bucket_id).get_public_url(file_path)
+
+    # Delete entry with image url from property_images table
+    supabase.table("property_images").delete().eq("url", public_url).execute()
+
+    return JSONResponse({"status": "ok"})
+  except Exception as e:
+    print("Error in /on-delete:", str(e))
+    return JSONResponse(status_code=500, content={"error": str(e)})
+
+@app.get("/health")
+def health_check():
+  return {"status": "ok"}
+
+
+if __name__ == "__main__":
+  uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=True)

model/top_classifier_head.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c5102343e6c8023c2f44ce6ddc559d29d50799a627acfa1d636def3ac939c7e
+size 676344

models.py

@@ -0,0 +1,15 @@
+import tensorflow as tf
+
+
+def create_models(IMG_SIZE):
+  """Create and return the base and top models"""
+  base_model = tf.keras.applications.MobileNetV2(
+    input_shape=(IMG_SIZE, IMG_SIZE, 3),
+    include_top=False,
+    weights="imagenet"
+  )
+  base_model.trainable = False
+
+  top_model = tf.keras.models.load_model("model/top_classifier_head.h5")
+  
+  return base_model, top_model

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn[standard]
+pillow
+tensorflow
+numpy
+supabase
+
+
+

services.json

@@ -0,0 +1,7 @@
+{
+  "EMBEDDINGS": "https://akafesu-fourwalls-embeddings-api.hf.space",
+  "RECOMMENDATIONS": "https://akafesu-fourwalls-recommendations-api.hf.space",
+  "CHAT": "https://akafesu-fourwalls-chat-api.hf.space",
+  "SUPABASE": "https://shhagbawphxfyehkqobv.supabase.co",
+  "MIGRATIONS": "https://akafesu-fourwalls-migrations-api.hf.space"
+}

supabase_client.py

@@ -0,0 +1,8 @@
+from supabase import create_client
+import os
+
+
+SUPABASE_URL = os.getenv('SUPABASE_URL')
+SUPABASE_SERVICE_ROLE_KEY = os.getenv('SUPABASE_SERVICE_ROLE_KEY')
+
+supabase = create_client(SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY)

tests/test_main.py

@@ -0,0 +1,36 @@
+from embeddings.main import preprocess_image, download_image_from_supabase, insert_property_image, health_check
+import pytest
+
+# Test preprocess_image
+
+def test_preprocess_image():
+    # Provide dummy image bytes (simulate a small PNG header)
+    image_bytes = b'\x89PNG\r\n\x1a\n' + b'0' * 100
+    try:
+        result = preprocess_image(image_bytes)
+        assert result is not None
+    except Exception:
+        # Acceptable if function raises for invalid image
+        assert True
+
+# Test download_image_from_supabase (mocked)
+def test_download_image_from_supabase(monkeypatch):
+    def mock_download(bucket_id, file_path):
+        return b"fake_image_bytes"
+    monkeypatch.setattr('embeddings.main.download_image_from_supabase', mock_download)
+    result = download_image_from_supabase('bucket', 'file.png')
+    assert result == b"fake_image_bytes"
+
+# Test insert_property_image (mocked DB)
+def test_insert_property_image():
+    # This function likely inserts into DB, so just check it runs
+    try:
+        insert_property_image(1, 'exterior', [0.1, 0.2], 0.99, 'http://example.com/img.png')
+        assert True
+    except Exception:
+        assert True
+
+# Test health_check
+def test_health_check():
+    result = health_check()
+    assert result is not None

tests/test_models.py

@@ -0,0 +1,6 @@
+from embeddings.models import create_models
+
+def test_create_models():
+    IMG_SIZE = (224, 224)
+    model = create_models(IMG_SIZE)
+    assert model is not None