s3 storage

Dockerfile

@@ -28,13 +28,11 @@
     # Copy built frontend into the image (served by FastAPI)
     COPY --from=fe /fe/dist /app/static
     
-    # Data dirs & sensible defaults (you can keep sqlite fallback if you want)
+    # Data dirs & sensible defaults
     RUN mkdir -p /data/uploads && chmod -R 777 /data
-    ENV STORAGE_PROVIDER=local
     ENV STORAGE_DIR=/data/uploads
     ENV HF_HOME=/data/.cache/huggingface
     
-    # Spaces provides PORT; default to 7860 locally
     ENV PORT=7860
     EXPOSE 7860
     

docker-compose.yml

@@ -9,7 +9,7 @@ services:
       POSTGRES_PASSWORD: promptaid
       POSTGRES_DB: promptaid
     ports:
-      - "5433:5432"
+      - "5434:5432"  # Changed from 5433 to avoid conflict
     volumes:
       - pgdata:/var/lib/postgresql/data
 
@@ -31,6 +31,7 @@ services:
     environment:
       MINIO_ROOT_USER: promptaid
       MINIO_ROOT_PASSWORD: promptaid
+      MINIO_DEFAULT_BUCKETS: promptaid
     ports:
       - "9000:9000"
       - "9001:9001"
@@ -38,6 +39,29 @@ services:
       - minio_data:/data
     depends_on:
       - postgres
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
+      interval: 30s
+      timeout: 20s
+      retries: 3
+
+  app:
+    build: .
+    ports:
+      - "8000:8000"
+    env_file:
+      - .env
+    environment:
+      - DATABASE_URL=postgresql://promptaid:promptaid@postgres:5432/promptaid
+      - S3_ENDPOINT=http://minio:9000  # Override for container networking
+    depends_on:
+      postgres:
+        condition: service_healthy
+      minio:
+        condition: service_healthy
+    volumes:
+      - ./py_backend:/app
+      - /app/__pycache__
 
 volumes:
   pgdata:

frontend/src/pages/AnalyticsPage/AnalyticsPage.tsx

@@ -184,7 +184,6 @@ export default function AnalyticsPage() {
       setTypesLookup(types);
       setRegionsLookup(regions);
     } catch {
-      // Silently handle errors for lookup data
     }
   }, []);
 

frontend/src/pages/MapDetailsPage/MapDetailPage.tsx

@@ -46,12 +46,10 @@ export default function MapDetailPage() {
   const [regions, setRegions] = useState<{r_code: string, label: string}[]>([]);
   const [countries, setCountries] = useState<{c_code: string, label: string, r_code: string}[]>([]);
   
-  // Carousel state
   const [hasPrevious, setHasPrevious] = useState(false);
   const [hasNext, setHasNext] = useState(false);
   const [isNavigating, setIsNavigating] = useState(false);
   
-  // Search and filter state
   const [search, setSearch] = useState('');
   const [srcFilter, setSrcFilter] = useState('');
   const [catFilter, setCatFilter] = useState('');
@@ -75,7 +73,6 @@ export default function MapDetailPage() {
       const data = await response.json();
       setMap(data);
       
-      // Check for previous/next items
       await checkNavigationAvailability(id);
     } catch (err: unknown) {
       setError(err instanceof Error ? err.message : 'Unknown error occurred');
@@ -97,7 +94,6 @@ export default function MapDetailPage() {
 
   const checkNavigationAvailability = async (currentId: string) => {
     try {
-      // Fetch all image IDs to determine navigation
       const response = await fetch('/api/images');
       if (response.ok) {
         const images = await response.json();
@@ -123,10 +119,8 @@ export default function MapDetailPage() {
       
       let targetIndex: number;
       if (direction === 'previous') {
-        // Wrap around to the last item if at the beginning
         targetIndex = currentIndex === 0 ? images.length - 1 : currentIndex - 1;
       } else {
-        // Wrap around to the first item if at the end
         targetIndex = currentIndex === images.length - 1 ? 0 : currentIndex + 1;
       }
       
@@ -155,18 +149,15 @@ export default function MapDetailPage() {
 
   const [isGenerating, setIsGenerating] = useState(false);
   
-  // Filter the current map based on search and filter criteria
   const filteredMap = useMemo(() => {
     if (!map) return null;
     
-    // Check if map matches search criteria
     const matchesSearch = !search || 
       map.title?.toLowerCase().includes(search.toLowerCase()) ||
       map.generated?.toLowerCase().includes(search.toLowerCase()) ||
       map.source?.toLowerCase().includes(search.toLowerCase()) ||
       map.event_type?.toLowerCase().includes(search.toLowerCase());
     
-    // Check if map matches filter criteria
     const matchesSource = !srcFilter || map.source === srcFilter;
     const matchesCategory = !catFilter || map.event_type === catFilter;
     const matchesRegion = !regionFilter || 

frontend/src/pages/UploadPage/UploadPage.tsx

@@ -344,7 +344,6 @@ export default function UploadPage() {
     if (!imageUrl) return;
     setIsLoading(true);
     try {
-      // 1) Create a NEW image from server-side URL fetch
       const res = await fetch('/api/contribute/from-url', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
@@ -463,7 +462,6 @@ export default function UploadPage() {
           throw new Error((json.error as string) || `Delete failed with status ${res.status}`);
         }
         
-        // If this was a contribution, navigate to explore page
         if (searchParams.get('isContribution') === 'true') {
           navigate('/explore');
         } else {

py_backend/alembic/env.py

@@ -2,10 +2,8 @@ import os
 import sys
 from dotenv import load_dotenv
 
-# Load local .env when running migrations locally
 load_dotenv()
 
-# Allow "from app import ..." imports
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
 from alembic import context
@@ -13,14 +11,14 @@ from sqlalchemy import create_engine, pool
 try:
     from app.models import Base
     target_metadata = Base.metadata
-    print(f"✅ Successfully imported models from app.models")
+    print("Successfully imported models from app.models")
 except ImportError as e:
-    print(f"⚠️ Could not import app.models: {e}")
-    print(f"🔍 Current working directory: {os.getcwd()}")
-    print(f"🔍 Python path: {sys.path}")
+    print(f"Could not import app.models: {e}")
+    print(f"Current working directory: {os.getcwd()}")
+    print(f"Python path: {sys.path}")
     from sqlalchemy import MetaData
     target_metadata = MetaData()
-    print(f"⚠️ Using fallback metadata - migrations may not work properly")
+    print("Using fallback metadata - migrations may not work properly")
 
 config = context.config
 target_metadata = Base.metadata
@@ -35,17 +33,15 @@ def _get_db_url() -> str:
     if not url:
         raise RuntimeError("Set ALEMBIC_DATABASE_URL or DATABASE_URL for Alembic migrations.")
 
-    print(f"🔍 Alembic database URL: {url}")
+    print(f"Alembic database URL: {url}")
     
-    # Clean the URL if it starts with 'psql ' (common in some environments)
     if url.startswith("psql '") and url.endswith("'"):
-        url = url[6:-1]  # Remove "psql '" prefix and "'" suffix
-        print(f"🔍 Cleaned URL: {url}")
+        url = url[6:-1]
+        print(f"Cleaned URL: {url}")
 
-    # Only add sslmode=require for remote connections, not localhost
     if "sslmode=" not in url and "localhost" not in url and "127.0.0.1" not in url:
         url = f"{url}{'&' if '?' in url else '?'}sslmode=require"
-        print(f"🔍 Added sslmode: {url}")
+        print(f"Added sslmode: {url}")
     
     return url
 
@@ -69,13 +65,13 @@ def run_migrations_online() -> None:
     """Run migrations in 'online' mode."""
     try:
         url = _get_db_url()
-        print(f"🔍 Creating engine with URL: {url}")
+        print(f"Creating engine with URL: {url}")
         
         connectable = create_engine(url, poolclass=pool.NullPool, future=True)
-        print(f"✅ Engine created successfully")
+        print("Engine created successfully")
 
         with connectable.connect() as connection:
-            print(f"✅ Database connection established")
+            print("Database connection established")
             context.configure(
                 connection=connection,
                 target_metadata=target_metadata,
@@ -83,14 +79,14 @@ def run_migrations_online() -> None:
                 compare_server_default=True,
             )
             with context.begin_transaction():
-                print(f"🔄 Running migrations...")
+                print("Running migrations...")
                 context.run_migrations()
-                print(f"✅ Migrations completed successfully")
+                print("Migrations completed successfully")
     except Exception as e:
-        print(f"❌ Migration failed: {e}")
-        print(f"🔍 Error type: {type(e).__name__}")
+        print(f"Migration failed: {e}")
+        print(f"Error type: {type(e).__name__}")
         import traceback
-        print(f"🔍 Full traceback: {traceback.format_exc()}")
+        print(f"Full traceback: {traceback.format_exc()}")
         raise
 
 

py_backend/alembic/versions/b8fc40bfe3c7_initial_schema_seed.py

@@ -42,7 +42,6 @@ def _guess_region(alpha2: str) -> str:
 def upgrade():
     op.execute('CREATE EXTENSION IF NOT EXISTS pgcrypto;')
     
-    # Drop any old tables if they exist (idempotent for initial setup)
     op.execute("DROP TABLE IF EXISTS captions CASCADE;")
     op.execute("DROP TABLE IF EXISTS image_countries CASCADE;")
     op.execute("DROP TABLE IF EXISTS images CASCADE;")
@@ -205,7 +204,6 @@ def upgrade():
         )
     op.execute("INSERT INTO countries (c_code,label,r_code) VALUES ('XX','Not Applicable','OTHER')")
 
-    # ---- Images table now includes the single caption/interpretation fields ----
     op.create_table(
         'images',
         sa.Column('image_id', postgresql.UUID(as_uuid=True),
@@ -220,7 +218,6 @@ def upgrade():
         sa.Column('created_at', sa.TIMESTAMP(timezone=True), server_default=sa.text('NOW()'), nullable=False),
         sa.Column('captured_at', sa.TIMESTAMP(timezone=True), nullable=True),
 
-        # --- merged caption fields ---
         sa.Column('title', sa.String(), nullable=True),
         sa.Column('prompt', sa.String(), nullable=True),
         sa.Column('model', sa.String(), sa.ForeignKey('models.m_code'), nullable=True),

py_backend/app/database.py

@@ -2,29 +2,25 @@ import os
 import logging
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker, declarative_base
-# from sqlalchemy.pool import NullPool  # optional for serverless
+
 
 from .config import settings
 
 raw_db_url = settings.DATABASE_URL
 
-# Clean the URL if it starts with 'psql ' (common in some environments)
 if raw_db_url.startswith("psql '") and raw_db_url.endswith("'"):
-    raw_db_url = raw_db_url[6:-1]  # Remove "psql '" prefix and "'" suffix
+    raw_db_url = raw_db_url[6:-1]
 
-# Only add sslmode=require for remote connections, not localhost
 if "sslmode=" not in raw_db_url and "localhost" not in raw_db_url and "127.0.0.1" not in raw_db_url:
     raw_db_url = f"{raw_db_url}{'&' if '?' in raw_db_url else '?'}sslmode=require"
 
-# Simple logging without URL parsing
-print(f"database url: {raw_db_url}")  
+    print(f"database url: {raw_db_url}")  
 
 engine = create_engine(
     raw_db_url,            
     pool_pre_ping=True,
     pool_recycle=300,        
-    # poolclass=NullPool,     
-    # echo=True,              
+                  
     future=True,
 )
 

py_backend/app/images.py

@@ -1,4 +1,4 @@
-# backend/app/schemas/images.py
+
 from pydantic import BaseModel, AnyHttpUrl, Field
 from typing import List, Optional
 

py_backend/app/main.py

@@ -1,4 +1,4 @@
-# py_backend/app/main.py
+
 import os
 import subprocess
 from datetime import datetime
@@ -15,7 +15,7 @@ app = FastAPI(title="PromptAid Vision")
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["http://localhost:3000","http://localhost:5173"],
+    allow_origins=["http://localhost:3000","http://localhost:5173","http://localhost:8000"],
     allow_origin_regex=r"https://.*\.hf\.space$",
     allow_credentials=False,
     allow_methods=["*"],
@@ -40,15 +40,20 @@ def root():
 <p>OK</p>
 <p><a href="/app/">Open UI</a> • <a href="/docs">API Docs</a></p>"""
 
-STATIC_DIR = "/app/static"
-print(f"🔍 Looking for static files in: {STATIC_DIR}")  # Debug line
+if os.path.exists("/app"):
+    STATIC_DIR = "/app/static"
+else:
+    STATIC_DIR = "../frontend/dist"
+
+print(f"Looking for static files in: {STATIC_DIR}")
 
 if os.path.isdir(STATIC_DIR):
-    print(f"✅ Static directory found: {STATIC_DIR}")
+    print(f"Static directory found: {STATIC_DIR}")
     app.mount("/app", StaticFiles(directory=STATIC_DIR, html=True), name="static")
 else:
-    print(f"❌ Static directory NOT found: {STATIC_DIR}")
-    print(f"📁 Current directory contents: {os.listdir(os.path.dirname(__file__))}")
+    print(f"Static directory NOT found: {STATIC_DIR}")
+    print(f"Current directory contents: {os.listdir(os.path.dirname(__file__))}")
+    print(f"Parent directory contents: {os.listdir(os.path.dirname(os.path.dirname(__file__)))}")
 
 @app.get("/app/{full_path:path}", include_in_schema=False)
 def spa_fallback(full_path: str):
@@ -90,7 +95,7 @@ async def debug_storage():
     if storage_exists:
         try:
             for root, dirs, filenames in os.walk(storage_dir):
-                for filename in filenames[:10]:  # Limit to first 10 files
+                for filename in filenames[:10]:
                     rel_path = os.path.relpath(os.path.join(root, filename), storage_dir)
                     files.append(rel_path)
         except Exception as e:
@@ -121,42 +126,42 @@ async def serve_upload(file_path: str):
 def run_migrations():
     """Run database migrations on startup"""
     try:
-        print("🔄 Running database migrations...")
+        print("Running database migrations...")
         
-        # Check what's available in the container
-        print("🔍 Checking container environment...")
+        current_dir = os.getcwd()
+        print(f"Current working directory: {current_dir}")
+        
+        print("Checking container environment...")
         try:
             result = subprocess.run(["which", "alembic"], capture_output=True, text=True)
-            print(f"📍 Alembic location: {result.stdout.strip() if result.stdout else 'Not found'}")
+            print(f"Alembic location: {result.stdout.strip() if result.stdout else 'Not found'}")
         except Exception as e:
-            print(f"⚠️ Could not check alembic location: {e}")
+            print(f"Could not check alembic location: {e}")
         
-        # Check the correct directory structure
-        print(f"📁 Checking if /app exists: {os.path.exists('/app')}")
+        print(f"Checking if /app exists: {os.path.exists('/app')}")
         if os.path.exists('/app'):
-            print(f"📁 Contents of /app: {os.listdir('/app')}")
+            print(f"Contents of /app: {os.listdir('/app')}")
         
-        # Find where alembic.ini is located
         alembic_paths = [
+            "alembic.ini",
+            "../alembic.ini",
+            "py_backend/alembic.ini",
             "/app/alembic.ini",
-            "/app/py_backend/alembic.ini", 
-            "/app/app/alembic.ini"
         ]
         
         alembic_dir = None
         for path in alembic_paths:
             if os.path.exists(path):
                 alembic_dir = os.path.dirname(path)
-                print(f"✅ Found alembic.ini at: {path}")
+                print(f"Found alembic.ini at: {path}")
                 break
         
         if not alembic_dir:
-            print("❌ Could not find alembic.ini - checking current directory")
-            alembic_dir = "/app"
+            print("Could not find alembic.ini - using current directory")
+            alembic_dir = current_dir
         
-        # Try to run alembic
         try:
-            print(f"🔍 Running alembic upgrade head from: {alembic_dir}")
+            print(f"Running alembic upgrade head from: {alembic_dir}")
             result = subprocess.run(
                 ["alembic", "upgrade", "head"],
                 cwd=alembic_dir,
@@ -164,32 +169,52 @@ def run_migrations():
                 text=True,
                 timeout=60
             )
-            print(f"📊 Alembic return code: {result.returncode}")
-            print(f"📊 Alembic stdout: {result.stdout}")
-            print(f"📊 Alembic stderr: {result.stderr}")
+            print(f"Alembic return code: {result.returncode}")
+            print(f"Alembic stdout: {result.stdout}")
+            print(f"Alembic stderr: {result.stderr}")
             
             if result.returncode == 0:
-                print("✅ Database migrations completed successfully")
+                print("Database migrations completed successfully")
             else:
-                print(f"❌ Database migrations failed")
-                print("🔄 Trying fallback: create tables directly...")
+                print(f"Database migrations failed")
+                print("Trying fallback: create tables directly...")
                 try:
                     from app.database import engine
                     from app.models import Base
                     Base.metadata.create_all(bind=engine)
-                    print("✅ Tables created directly via SQLAlchemy")
+                    print("Tables created directly via SQLAlchemy")
                 except Exception as fallback_error:
-                    print(f"❌ Fallback also failed: {fallback_error}")
+                    print(f"Fallback also failed: {fallback_error}")
         except Exception as e:
-            print(f"❌ Error running alembic: {e}")
+            print(f"Error running alembic: {e}")
         
     except Exception as e:
-        print(f"⚠️ Could not run migrations: {e}")
+        print(f"Could not run migrations: {e}")
+
+
+def ensure_storage_ready():
+    """Ensure MinIO storage is ready before starting the app"""
+    print(f"Storage provider from settings: '{settings.STORAGE_PROVIDER}'")
+    print(f"S3 endpoint from settings: '{settings.S3_ENDPOINT}'")
+    print(f"S3 bucket from settings: '{settings.S3_BUCKET}'")
+    
+    if settings.STORAGE_PROVIDER == "s3":
+        try:
+            print("Checking MinIO storage connection...")
+            from app.storage import _ensure_bucket
+            _ensure_bucket()
+            print("MinIO storage ready")
+        except Exception as e:
+            print(f"Warning: MinIO storage not ready: {e}")
+            print("Storage operations may fail until MinIO is available")
+    else:
+        print("Using local storage - no external dependencies")
 
-# Run migrations on startup
 run_migrations()
 
-print("🚀 PromptAid Vision API server ready")
-print("📊 Endpoints: /api/images, /api/captions, /api/metadata, /api/models")
-print(f"🌍 Environment: {settings.ENVIRONMENT}")
-print("🔗 CORS: localhost + *.hf.space")
+ensure_storage_ready()
+
+print("PromptAid Vision API server ready")
+print("Endpoints: /api/images, /api/captions, /api/metadata, /api/models")
+print(f"Environment: {settings.ENVIRONMENT}")
+print("CORS: localhost + *.hf.space")

py_backend/app/routers/caption.py

@@ -80,28 +80,23 @@ async def create_caption(
         raise HTTPException(404, "image not found")
 
     try:
-        # Try to get image bytes using storage functions
         if hasattr(storage, 's3') and settings.STORAGE_PROVIDER != "local":
-            # S3/MinIO path
             response = storage.s3.get_object(
                 Bucket=settings.S3_BUCKET,
                 Key=img.file_key,
             )
             img_bytes = response["Body"].read()
         else:
-            # Local storage path - read file directly
             import os
             file_path = os.path.join(settings.STORAGE_DIR, img.file_key)
             with open(file_path, 'rb') as f:
                 img_bytes = f.read()
     except Exception as e:
         print(f"Error reading image file: {e}")
-        # Fallback: try to get via URL
         try:
             url = storage.generate_presigned_url(img.file_key)
             if url.startswith('/'):
-                # Local storage - construct full URL
-                url = f"http://localhost:7860{url}"
+                url = f"http://localhost:8000{url}"
             import requests
             resp = requests.get(url)
             resp.raise_for_status()
@@ -144,9 +139,8 @@ async def create_caption(
     from .upload import convert_image_to_dict
     try:
         url = storage.generate_presigned_url(c.file_key, expires_in=3600)
-        # For local storage, ensure we have a full URL
         if url.startswith('/') and settings.STORAGE_PROVIDER == "local":
-            url = f"http://localhost:7860{url}"
+            url = f"http://localhost:8000{url}"
     except Exception:
         url = f"/api/images/{c.image_id}/file"
     
@@ -173,9 +167,8 @@ def get_caption(
     from .upload import convert_image_to_dict
     try:
         url = storage.generate_presigned_url(caption.file_key, expires_in=3600)
-        # For local storage, ensure we have a full URL
         if url.startswith('/') and settings.STORAGE_PROVIDER == "local":
-            url = f"http://localhost:7860{url}"
+            url = f"http://localhost:8000{url}"
     except Exception:
         url = f"/api/images/{caption.image_id}/file"
     

py_backend/app/routers/images.py

@@ -21,37 +21,34 @@ def get_db():
 
 @router.post("/from-url", response_model=CreateImageFromUrlOut)
 async def create_image_from_url(payload: CreateImageFromUrlIn, db: Session = Depends(get_db)):
-    print(f"DEBUG: Received payload: {payload}")
     try:
-        if payload.url.startswith('/api/images/') and '/file' in payload.url:
-            image_id = payload.url.split('/api/images/')[1].split('/file')[0]
-            print(f"DEBUG: Extracted image_id: {image_id}")
+        if '/api/images/' in payload.url and '/file' in payload.url:
+            url_parts = payload.url.split('/api/images/')
+            if len(url_parts) > 1:
+                image_id = url_parts[1].split('/file')[0]
+            else:
+                raise HTTPException(status_code=400, detail="Invalid image URL format")
         else:
             raise HTTPException(status_code=400, detail="Invalid image URL format")
         
         existing_image = db.query(Images).filter(Images.image_id == image_id).first()
         if not existing_image:
             raise HTTPException(status_code=404, detail="Source image not found")
-        print(f"DEBUG: Found existing image: {existing_image.image_id}")
         
         try:
-            # Try to get image content using storage functions
             if hasattr(storage, 's3') and settings.STORAGE_PROVIDER != "local":
-                # S3/MinIO path
                 response = storage.s3.get_object(
                     Bucket=settings.S3_BUCKET,
                     Key=existing_image.file_key,
                 )
                 data = response["Body"].read()
             else:
-                # Local storage path - read file directly
                 import os
                 file_path = os.path.join(settings.STORAGE_DIR, existing_image.file_key)
                 with open(file_path, 'rb') as f:
                     data = f.read()
             
             content_type = "image/jpeg"
-            print(f"DEBUG: Downloaded image data: {len(data)} bytes")
         except Exception as e:
             raise HTTPException(status_code=400, detail=f"Failed to fetch image from storage: {e}")
         
@@ -61,10 +58,8 @@ async def create_image_from_url(payload: CreateImageFromUrlIn, db: Session = Dep
         ext = mimetypes.guess_extension(content_type) or ".jpg"
         key = upload_bytes(data, filename=f"contributed{ext}", content_type=content_type)
         image_url = get_object_url(key, expires_in=86400)
-        print(f"DEBUG: Uploaded new image with key: {key}")
 
         sha = hashlib.sha256(data).hexdigest()
-        print(f"DEBUG: Creating new Images object...")
 
         img = Images(
             file_key=key,
@@ -85,22 +80,17 @@ async def create_image_from_url(payload: CreateImageFromUrlIn, db: Session = Dep
             usability=50,
             starred=False
         )
-        print(f"DEBUG: Images object created: {img}")
         db.add(img)
-        db.flush()  # get image_id
-        print(f"DEBUG: New image_id: {img.image_id}")
+        db.flush()
 
         for c in payload.countries:
             db.execute(image_countries.insert().values(image_id=img.image_id, c_code=c))
 
         db.commit()
-        print(f"DEBUG: Database commit successful")
 
         result = CreateImageFromUrlOut(image_id=str(img.image_id), image_url=image_url)
-        print(f"DEBUG: Returning result: {result}")
         return result
         
     except Exception as e:
-        print(f"DEBUG: Exception occurred: {type(e).__name__}: {str(e)}")
         db.rollback()
         raise HTTPException(status_code=500, detail=f"Failed to create image: {str(e)}")

py_backend/app/routers/upload.py

@@ -141,16 +141,13 @@ async def copy_image_for_contribution(
         raise HTTPException(404, "Source image not found")
     
     try:
-        # Try to get image content using storage functions
         if hasattr(storage, 's3') and settings.STORAGE_PROVIDER != "local":
-            # S3/MinIO path
             response = storage.s3.get_object(
                 Bucket=settings.S3_BUCKET,
                 Key=source_img.file_key,
             )
             image_content = response["Body"].read()
         else:
-            # Local storage path - read file directly
             import os
             file_path = os.path.join(settings.STORAGE_DIR, source_img.file_key)
             with open(file_path, 'rb') as f:
@@ -197,14 +194,11 @@ async def get_image_file(image_id: str, db: Session = Depends(get_db)):
     print(f"✅ Found image: {img.image_id}, file_key: {img.file_key}")
     
     try:
-        # Try to get image content using storage functions
         if hasattr(storage, 's3') and settings.STORAGE_PROVIDER != "local":
-            # S3/MinIO path
             print(f"🔍 Using S3 storage")
             response = storage.s3.get_object(Bucket=settings.S3_BUCKET, Key=img.file_key)
             content = response['Body'].read()
         else:
-            # Local storage path - read file directly
             print(f"🔍 Using local storage")
             import os
             file_path = os.path.join(settings.STORAGE_DIR, img.file_key)

py_backend/app/services/vlm_service.py

@@ -65,14 +65,12 @@ class VLMServiceManager:
     async def generate_caption(self, image_bytes: bytes, prompt: str, model_name: str | None = None) -> dict:
         """Generate caption using the specified model or fallback to available service."""
         
-        # Find appropriate service
         service = None
         if model_name:
             service = self.services.get(model_name)
             if not service:
                 print(f"Model '{model_name}' not found, using fallback")
         
-        # Fallback to first available service
         if not service and self.services:
             service = next(iter(self.services.values()))
             print(f"Using fallback service: {service.model_name}")

py_backend/app/storage.py

@@ -6,7 +6,6 @@ from typing import BinaryIO, Optional
 
 from .config import settings
 
-# Initialize s3 client based on storage provider
 if settings.STORAGE_PROVIDER != "local":
     import boto3
     import botocore
@@ -19,7 +18,6 @@ if settings.STORAGE_PROVIDER != "local":
         region_name=getattr(settings, "S3_REGION", None),
     )
 else:
-    # Create a dummy s3 object for local storage to avoid AttributeError
     class DummyS3Client:
         def __init__(self):
             pass
@@ -32,38 +30,26 @@ else:
     
     s3 = DummyS3Client()
 
-# Optional settings you can add to your config:
-# - S3_PUBLIC_URL_BASE: str | None  (e.g. "https://cdn.example.com" or bucket website endpoint)
-# - S3_PUBLIC_READ: bool            (True if the bucket/objects are world-readable)
 
 def _ensure_bucket() -> None:
-    """
-    Make sure the bucket exists. Safe to call on every upload.
-    """
+    """Ensure bucket exists. Safe to call on every upload."""
     if settings.STORAGE_PROVIDER == "local":
-        # For local storage, ensure the storage directory exists
         os.makedirs(settings.STORAGE_DIR, exist_ok=True)
         return
         
     try:
         s3.head_bucket(Bucket=settings.S3_BUCKET)
     except botocore.exceptions.ClientError as e:
-        # Create bucket. Some providers need LocationConstraint; MinIO typically doesn't.
         create_kwargs = {"Bucket": settings.S3_BUCKET}
         region = getattr(settings, "S3_REGION", None)
-        # For AWS S3 outside us-east-1 you must pass LocationConstraint.
         if region and (settings.S3_ENDPOINT is None or "amazonaws.com" in str(settings.S3_ENDPOINT).lower()):
             create_kwargs["CreateBucketConfiguration"] = {"LocationConstraint": region}
         s3.create_bucket(**create_kwargs)
 
 
 def get_object_url(key: str, *, expires_in: int = 3600) -> str:
-    """
-    Return a browser-usable URL for the object.
-    If S3_PUBLIC_URL_BASE is set, return a public URL. Otherwise, return a presigned URL.
-    """
+    """Return browser-usable URL for object."""
     if settings.STORAGE_PROVIDER == "local":
-        # For local storage, return a relative path that can be served by FastAPI
         return f"/uploads/{key}"
     
     public_base = getattr(settings, "S3_PUBLIC_URL_BASE", None)
@@ -73,11 +59,8 @@ def get_object_url(key: str, *, expires_in: int = 3600) -> str:
 
 
 def generate_presigned_url(key: str, expires_in: int = 3600) -> str:
-    """
-    Returns a presigned URL for GETting the object.
-    """
+    """Generate presigned URL for GETting object."""
     if settings.STORAGE_PROVIDER == "local":
-        # For local storage, return a direct URL
         return f"/uploads/{key}"
     
     return s3.generate_presigned_url(
@@ -94,10 +77,7 @@ def upload_fileobj(
     content_type: Optional[str] = None,
     cache_control: Optional[str] = "public, max-age=31536000, immutable",
 ) -> str:
-    """
-    Upload a file-like object to the configured storage.
-    Returns the object key (not the URL).
-    """
+    """Upload file-like object to configured storage. Returns object key."""
     if settings.STORAGE_PROVIDER == "local":
         return _upload_local(fileobj, filename, content_type)
     else:
@@ -109,18 +89,14 @@ def _upload_local(
     content_type: Optional[str] = None,
 ) -> str:
     """Upload to local filesystem"""
-    # Ensure storage directory exists
     os.makedirs(settings.STORAGE_DIR, exist_ok=True)
     
-    # Build a namespaced key
     safe_name = filename or "upload.bin"
     key = f"maps/{uuid4()}_{safe_name}"
     filepath = os.path.join(settings.STORAGE_DIR, key)
     
-    # Ensure directory exists
     os.makedirs(os.path.dirname(filepath), exist_ok=True)
     
-    # Write file
     with open(filepath, 'wb') as f:
         fileobj.seek(0)
         f.write(fileobj.read())
@@ -136,14 +112,11 @@ def _upload_s3(
     """Upload to S3/MinIO"""
     _ensure_bucket()
 
-    # Build a namespaced key; keep original filename tail if helpful
     safe_name = filename or "upload.bin"
     key = f"maps/{uuid4()}_{safe_name}"
 
-    # Guess content type if not provided
     ct = content_type or (mimetypes.guess_type(safe_name)[0] or "application/octet-stream")
 
-    # Make sure we read from the start
     try:
         fileobj.seek(0)
     except Exception:
@@ -153,7 +126,6 @@ def _upload_s3(
     if cache_control:
         extra_args["CacheControl"] = cache_control
     if getattr(settings, "S3_PUBLIC_READ", False):
-        # Only set this if your bucket policy allows public read
         extra_args["ACL"] = "public-read"
 
     s3.upload_fileobj(fileobj, settings.S3_BUCKET, key, ExtraArgs=extra_args)
@@ -167,9 +139,7 @@ def upload_bytes(
     content_type: Optional[str] = None,
     cache_control: Optional[str] = "public, max-age=31536000, immutable",
 ) -> str:
-    """
-    Convenience helper to upload raw bytes (e.g., after server-side URL download).
-    """
+    """Upload raw bytes. Returns object key."""
     buf = io.BytesIO(data)
     return upload_fileobj(buf, filename, content_type=content_type, cache_control=cache_control)
 
@@ -180,11 +150,7 @@ def copy_object(
     new_filename: Optional[str] = None,
     cache_control: Optional[str] = "public, max-age=31536000, immutable",
 ) -> str:
-    """
-    Server-side copy within the same bucket (no download/upload round-trip).
-    Useful for 'duplicate' endpoints if you already know the source key.
-    Returns the NEW object key.
-    """
+    """Server-side copy within same bucket. Returns new object key."""
     if settings.STORAGE_PROVIDER == "local":
         return _copy_local(src_key, new_filename)
     else:
@@ -200,10 +166,8 @@ def _copy_local(src_key: str, new_filename: Optional[str] = None) -> str:
     dest_key = f"maps/{uuid4()}_{tail}"
     dest_path = os.path.join(settings.STORAGE_DIR, dest_key)
     
-    # Ensure directory exists
     os.makedirs(os.path.dirname(dest_path), exist_ok=True)
     
-    # Copy file
     with open(src_path, 'rb') as src, open(dest_path, 'wb') as dest:
         dest.write(src.read())
     
@@ -231,9 +195,7 @@ def _copy_s3(src_key: str, new_filename: Optional[str] = None, cache_control: Op
 
 
 def delete_object(key: str) -> None:
-    """
-    Delete an object (best-effort).
-    """
+    """Delete object (best-effort)."""
     if settings.STORAGE_PROVIDER == "local":
         _delete_local(key)
     else:
@@ -246,7 +208,6 @@ def _delete_local(key: str) -> None:
         if os.path.exists(file_path):
             os.remove(file_path)
     except (OSError, FileNotFoundError):
-        # Swallow to keep deletes idempotent for callers
         pass
 
 def _delete_s3(key: str) -> None:
@@ -254,5 +215,4 @@ def _delete_s3(key: str) -> None:
     try:
         s3.delete_object(Bucket=settings.S3_BUCKET, Key=key)
     except botocore.exceptions.ClientError:
-        # Swallow to keep deletes idempotent for callers
         pass

py_backend/tests/test_explore_page.py

@@ -6,7 +6,6 @@ import requests
 import sys
 import os
 
-# Add the parent directory to the path
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
 
 from app.database import SessionLocal
@@ -18,7 +17,6 @@ def test_explore_page_endpoints():
     
     base_url = "http://localhost:8000/api"
     
-    # Test metadata endpoints
     endpoints = [
         "/sources",
         "/types", 
@@ -52,7 +50,6 @@ def test_images_list_endpoint():
             data = response.json()
             print(f"  + {len(data)} images returned")
             
-            # Check structure of first image
             if data:
                 first_image = data[0]
                 required_fields = ['image_id', 'file_key', 'source', 'type', 'image_url']
@@ -71,7 +68,6 @@ def test_image_detail_endpoint():
     """Test the image detail endpoint"""
     print("\n=== Testing Image Detail Endpoint ===")
     
-    # First get a list of images
     try:
         response = requests.get("http://localhost:8000/api/images/")
         if response.status_code == 200:
@@ -79,7 +75,6 @@ def test_image_detail_endpoint():
             if images:
                 image_id = images[0]['image_id']
                 
-                # Test getting specific image
                 detail_response = requests.get(f"http://localhost:8000/api/images/{image_id}")
                 print(f"GET /api/images/{image_id}: {detail_response.status_code}")
                 
@@ -103,7 +98,6 @@ def test_image_file_endpoint():
     """Test the image file serving endpoint"""
     print("\n=== Testing Image File Endpoint ===")
     
-    # First get a list of images
     try:
         response = requests.get("http://localhost:8000/api/images/")
         if response.status_code == 200:
@@ -111,7 +105,6 @@ def test_image_file_endpoint():
             if images:
                 image_id = images[0]['image_id']
                 
-                # Test getting image file
                 file_response = requests.get(f"http://localhost:8000/api/images/{image_id}/file")
                 print(f"GET /api/images/{image_id}/file: {file_response.status_code}")
                 
@@ -133,27 +126,22 @@ def test_filtering_functionality():
     """Test the filtering functionality"""
     print("\n=== Testing Filtering Functionality ===")
     
-    # Test filtering by source
     try:
         response = requests.get("http://localhost:8000/api/images/")
         if response.status_code == 200:
             images = response.json()
             if images:
-                # Get unique sources
                 sources = list(set(img['source'] for img in images))
                 print(f"  + Available sources: {sources}")
                 
-                # Test filtering by first source
                 if sources:
                     first_source = sources[0]
                     filtered_images = [img for img in images if img['source'] == first_source]
                     print(f"  + Filtered by source '{first_source}': {len(filtered_images)} images")
                 
-                # Get unique types
                 types = list(set(img['type'] for img in images))
                 print(f"  + Available types: {types}")
                 
-                # Test filtering by first type
                 if types:
                     first_type = types[0]
                     filtered_images = [img for img in images if img['type'] == first_type]
@@ -172,15 +160,12 @@ def test_database_consistency():
     
     db = SessionLocal()
     try:
-        # Check if images exist
         images = db.query(models.Images).all()
         print(f"  + Total images in database: {len(images)}")
         
-        # Check if images have caption data
         images_with_captions = db.query(models.Images).filter(models.Images.title.isnot(None)).all()
         print(f"  + Images with caption data: {len(images_with_captions)}")
         
-        # Check metadata tables
         sources = db.query(models.Source).all()
         print(f"  + Total sources: {len(sources)}")
         
@@ -190,7 +175,6 @@ def test_database_consistency():
         countries = db.query(models.Country).all()
         print(f"  + Total countries: {len(countries)}")
         
-        # Check relationships
         images_with_countries = db.query(models.Images).join(models.Images.countries).all()
         print(f"  + Images with countries: {len(images_with_countries)}")
         
@@ -205,7 +189,6 @@ def create_test_data():
     
     db = SessionLocal()
     try:
-        # Create a test image
         test_content = b"test image data for explore page"
         key = storage.upload_fileobj(io.BytesIO(test_content), "explore_test.jpg")
         
@@ -221,7 +204,6 @@ def create_test_data():
         )
         print(f"  + Created test image: {img.image_id}")
         
-        # Create a test caption
         caption = crud.create_caption(
             db=db,
             image_id=img.image_id,
@@ -259,10 +241,8 @@ def cleanup_test_data(image_id):
 if __name__ == "__main__":
     print("Starting Explore Page Tests...")
     
-    # Create test data
     test_image_id = create_test_data()
     
-    # Run tests
     test_explore_page_endpoints()
     test_images_list_endpoint()
     test_image_detail_endpoint()
@@ -270,7 +250,6 @@ if __name__ == "__main__":
     test_filtering_functionality()
     test_database_consistency()
     
-    # Clean up
     if test_image_id:
         cleanup_test_data(test_image_id)
     

py_backend/tests/test_openai_integration.py

@@ -9,7 +9,6 @@ import os
 from pathlib import Path
 import sys
 
-# Add the app directory to the Python path
 sys.path.append(os.path.join(os.path.dirname(__file__), 'app'))
 
 from app.services.gpt4v_service import GPT4VService
@@ -20,7 +19,6 @@ async def test_gpt4v_service():
     print("🧪 OpenAI GPT-4 Vision Integration Test")
     print("=" * 60)
     
-    # Check API key
     if not settings.OPENAI_API_KEY:
         print("❌ OPENAI_API_KEY environment variable not set!")
         print("Please set your OpenAI API key in .env:")
@@ -29,7 +27,6 @@ async def test_gpt4v_service():
     
     print(f"✅ OpenAI API Key found: {settings.OPENAI_API_KEY[:10]}...")
     
-    # Find test image
     test_image_path = Path("tests/test.jpg")
     if not test_image_path.exists():
         print(f"❌ Test image not found at: {test_image_path}")
@@ -38,7 +35,6 @@ async def test_gpt4v_service():
     
     print(f"✅ Test image found: {test_image_path}")
     
-    # Initialize GPT4V service
     try:
         gpt4v_service = GPT4VService(settings.OPENAI_API_KEY)
         print(f"✅ GPT4V service initialized: {gpt4v_service.model_name}")
@@ -46,13 +42,11 @@ async def test_gpt4v_service():
         print(f"❌ Failed to initialize GPT4V service: {e}")
         return
     
-    # Read test image
     with open(test_image_path, 'rb') as f:
         image_bytes = f.read()
     
     print(f"📸 Image size: {len(image_bytes)} bytes")
     
-    # Test caption generation
     prompt = "Analyze this crisis map and provide a detailed description of the emergency situation, affected areas, and key information shown in the map."
     
     print(f"\n🎯 Testing with prompt: {prompt}")

py_backend/tests/test_upload_flow.py

@@ -4,7 +4,6 @@
 import sys
 import os
 
-# Add the parent directory to the path so we can import app modules
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
 
 import requests
@@ -19,11 +18,9 @@ def test_database_connection():
     try:
         print("Testing database connection...")
         
-        # Test basic query
         sources = db.query(models.Source).all()
         print(f"Found {len(sources)} sources in database")
         
-        # Test image creation
         test_img = models.Images(
             file_key="test_key",
             sha256="test_sha",
@@ -43,7 +40,6 @@ def test_database_connection():
         db.commit()
         print(f"Created test image with ID: {test_img.image_id}")
         
-        # Clean up
         db.delete(test_img)
         db.commit()
         print("Test completed successfully - database is working")
@@ -60,7 +56,6 @@ def test_crud_functions():
     try:
         print("Testing CRUD functions...")
         
-        # Test create_image
         img = crud.create_image(
             db=db,
             src="OTHER",
@@ -73,7 +68,6 @@ def test_crud_functions():
         )
         print(f"CRUD create_image successful: {img.image_id}")
         
-        # Test create_caption
         caption = crud.create_caption(
             db=db,
             image_id=img.image_id,
@@ -85,7 +79,6 @@ def test_crud_functions():
         )
         print(f"CRUD create_caption successful for image: {caption.image_id}")
         
-        # Clean up
         db.delete(img)
         db.commit()
         print("CRUD test completed successfully")
@@ -100,11 +93,9 @@ def test_complete_upload_flow():
     """Test the complete upload flow: upload → create caption → submit caption"""
     print("=== Testing Complete Upload Flow ===")
     
-    # Create test image data
     test_content = b"test image data for upload flow"
     test_filename = "test_upload.jpg"
     
-    # Step 1: Upload image via API
     print("1. Uploading image via API...")
     files = {'file': (test_filename, io.BytesIO(test_content), 'image/jpeg')}
     data = {
@@ -124,7 +115,6 @@ def test_complete_upload_flow():
             image_id = upload_result['image_id']
             print(f"Upload successful! Image ID: {image_id}")
             
-            # Step 2: Create caption via API
             print("2. Creating caption via API...")
             caption_data = {
                 'title': 'Test Caption',
@@ -139,10 +129,9 @@ def test_complete_upload_flow():
             
             if caption_response.status_code == 200:
                 caption_result = caption_response.json()
-                caption_id = caption_result['image_id']  # Now using image_id instead of cap_id
+                caption_id = caption_result['image_id']
                 print(f"Caption created successfully! Caption ID: {caption_id}")
                 
-                # Step 3: Submit caption via API
                 print("3. Submitting caption via API...")
                 submit_data = {
                     'title': 'Test Caption',
@@ -161,7 +150,6 @@ def test_complete_upload_flow():
                 if submit_response.status_code == 200:
                     print("Caption submitted successfully!")
                     
-                    # Verify in database
                     print("4. Verifying in database...")
                     db = SessionLocal()
                     try:
@@ -191,11 +179,9 @@ def test_deletion_logic():
     """Test the deletion logic for images"""
     print("=== Testing Deletion Logic ===")
     
-    # Create test image data
     test_content = b"test image data for deletion test"
     test_filename = "test_deletion.jpg"
     
-    # Step 1: Upload image via API
     print("1. Uploading image via API...")
     files = {'file': (test_filename, io.BytesIO(test_content), 'image/jpeg')}
     data = {
@@ -215,7 +201,6 @@ def test_deletion_logic():
             image_id = upload_result['image_id']
             print(f"Upload successful! Image ID: {image_id}")
             
-            # Step 2: Create caption via API
             print("2. Creating caption via API...")
             caption_data = {
                 'title': 'Test Caption for Deletion',
@@ -231,7 +216,6 @@ def test_deletion_logic():
             if caption_response.status_code == 200:
                 print("Caption created successfully!")
                 
-                # Step 3: Test image deletion
                 print("3. Testing image deletion...")
                 delete_response = requests.delete(
                     f'http://localhost:8080/api/images/{image_id}'
@@ -241,7 +225,6 @@ def test_deletion_logic():
                 if delete_response.status_code == 200:
                     print("Image deleted successfully!")
                     
-                    # Verify image is completely removed
                     print("4. Verifying image deletion...")
                     db = SessionLocal()
                     try:

start-local.bat

@@ -0,0 +1,39 @@
+@echo off
+echo 🚀 Starting PromptAid Vision Local Development Environment...
+echo.
+
+echo 1. Starting MinIO and PostgreSQL...
+docker-compose up -d postgres minio
+
+echo.
+echo 2. Waiting for services to be ready...
+timeout /t 15 /nobreak >nul
+
+echo.
+echo 3. Starting Backend on port 8000...
+cd py_backend
+call .venv\Scripts\activate
+start "Backend" cmd /k "uvicorn app.main:app --reload --host 0.0.0.0 --port 8000"
+
+echo.
+echo ✅ All Services Started:
+echo    PostgreSQL: localhost:5434
+echo    MinIO: localhost:9000
+echo    MinIO Console: http://localhost:9001
+echo    Backend: Port 8000
+echo.
+echo 🌐 URLs:
+echo    Your App: http://localhost:8000/app/
+echo    API Docs: http://localhost:8000/docs
+echo    Health Check: http://localhost:8000/health
+echo    MinIO Console: http://localhost:9001 (promptaid/promptaid)
+echo.
+echo 🎯 Main App URL: http://localhost:8000/app/
+echo.
+echo Press any key to stop all services...
+pause >nul
+
+echo.
+echo 🛑 Stopping all services...
+docker-compose down
+echo ✅ Services stopped.

start-local.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+echo "🚀 Starting PromptAid Vision Local Development Environment..."
+echo ""
+
+echo "1. Starting MinIO and PostgreSQL..."
+docker-compose up -d postgres minio
+
+echo ""
+echo "2. Waiting for services to be ready..."
+sleep 15
+
+echo ""
+echo "3. Starting Backend on port 8000..."
+cd py_backend
+source .venv/bin/activate
+uvicorn app.main:app --reload --host 0.0.0.0 --port 8000 &
+BACKEND_PID=$!
+
+echo ""
+echo "✅ All Services Started:"
+echo "   PostgreSQL: localhost:5434"
+echo "   MinIO: localhost:9000"
+echo "   MinIO Console: http://localhost:9001"
+echo "   Backend PID: $BACKEND_PID (Port 8000)"
+echo ""
+echo "🌐 URLs:"
+echo "   Your App: http://localhost:8000/app/"
+echo "   API Docs: http://localhost:8000/docs"
+echo "   Health Check: http://localhost:8000/health"
+echo "   MinIO Console: http://localhost:9001 (promptaid/promptaid)"
+echo ""
+echo "🎯 Main App URL: http://localhost:8000/app/"
+echo ""
+echo "Press Ctrl+C to stop all services"
+
+# Function to cleanup on exit
+cleanup() {
+    echo ""
+    echo "🛑 Stopping all services..."
+    docker-compose down
+    kill $BACKEND_PID 2>/dev/null
+    echo "✅ All services stopped"
+    exit 0
+}
+
+# Set trap to cleanup on script exit
+trap cleanup INT TERM EXIT
+
+# Wait for both processes
+wait