database images table transformation

frontend/src/pages/AnalyticsPage/AnalyticsPage.tsx

@@ -210,7 +210,7 @@ export default function AnalyticsPage() {
           if (map.context != null) ctr.avgContext += map.context;
           if (map.usability != null) ctr.avgUsability += map.usability;
           
-          // Calculate edit time if both timestamps exist
+          // Calculate edit time if both timestamps exist (now from captions)
           if (map.created_at && map.updated_at) {
             const created = new Date(map.created_at).getTime();
             const updated = new Date(map.updated_at).getTime();

frontend/src/pages/ExplorePage/ExplorePage.tsx

@@ -62,7 +62,7 @@ export default function ExplorePage() {
 
   const fetchCaptions = () => {
     setIsLoadingContent(true);
-    fetch('/api/captions')
+    fetch('/api/captions/legacy')
       .then(r => {
         if (!r.ok) {
           throw new Error(`HTTP ${r.status}: ${r.statusText}`);

py_backend/alembic/versions/0016_restructure_images_to_three_tables.py

@@ -0,0 +1,206 @@
+"""Restructure images table into three tables: Images, Captions, and Images_captions
+
+Revision ID: 0016
+Revises: 0015
+Create Date: 2024-01-01 00:00:00.000000
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = '0016'
+down_revision = '0015'
+branch_labels = None
+depends_on = None
+
+def upgrade():
+    # Ensure pgcrypto extension is available
+    op.execute('CREATE EXTENSION IF NOT EXISTS pgcrypto;')
+    
+    # First, ensure the old images table has all the caption columns
+    # (in case they were removed by a previous partial migration)
+    connection = op.get_bind()
+    
+    # Check if caption columns exist and add them if they don't
+    caption_columns = [
+        ('title', 'VARCHAR'),
+        ('prompt', 'VARCHAR'),
+        ('model', 'VARCHAR'),
+        ('schema_id', 'VARCHAR'),
+        ('raw_json', 'JSONB'),
+        ('generated', 'TEXT'),
+        ('edited', 'TEXT'),
+        ('accuracy', 'SMALLINT'),
+        ('context', 'SMALLINT'),
+        ('usability', 'SMALLINT'),
+        ('starred', 'BOOLEAN'),
+        ('updated_at', 'TIMESTAMP WITH TIME ZONE'),
+        ('created_at', 'TIMESTAMP WITH TIME ZONE')
+    ]
+    
+    for col_name, col_type in caption_columns:
+        result = connection.execute(sa.text(f"""
+            SELECT COUNT(*) FROM information_schema.columns 
+            WHERE table_name = 'images' AND column_name = '{col_name}'
+        """))
+        if result.scalar() == 0:
+            if col_type == 'BOOLEAN':
+                op.add_column('images', sa.Column(col_name, sa.Boolean(), nullable=True, server_default='false'))
+            elif col_type == 'TIMESTAMP WITH TIME ZONE':
+                op.add_column('images', sa.Column(col_name, sa.TIMESTAMP(timezone=True), nullable=True))
+            else:
+                op.add_column('images', sa.Column(col_name, sa.String() if col_type == 'VARCHAR' else sa.Text() if col_type == 'TEXT' else sa.SmallInteger(), nullable=True))
+    
+    # Create new Images table with temporary caption_id column for mapping
+    op.create_table(
+        'images_new',
+        sa.Column('image_id', postgresql.UUID(as_uuid=True),
+                  server_default=sa.text('gen_random_uuid()'),
+                  primary_key=True),
+        sa.Column('file_key', sa.String(), nullable=False),
+        sa.Column('sha256', sa.String(), nullable=False),
+        sa.Column('source', sa.String(), sa.ForeignKey('sources.s_code'), nullable=True),
+        sa.Column('event_type', sa.String(), sa.ForeignKey('event_types.t_code'), nullable=False),
+        sa.Column('epsg', sa.String(), sa.ForeignKey('spatial_references.epsg'), nullable=False),
+        sa.Column('image_type', sa.String(), sa.ForeignKey('image_types.image_type'), nullable=False),
+        sa.Column('captured_at', sa.TIMESTAMP(timezone=True), nullable=True),
+        sa.Column('center_lon', sa.Float(precision=53), nullable=True),
+        sa.Column('center_lat', sa.Float(precision=53), nullable=True),
+        sa.Column('amsl_m', sa.Float(precision=53), nullable=True),
+        sa.Column('agl_m', sa.Float(precision=53), nullable=True),
+        sa.Column('heading_deg', sa.Float(precision=53), nullable=True),
+        sa.Column('yaw_deg', sa.Float(precision=53), nullable=True),
+        sa.Column('pitch_deg', sa.Float(precision=53), nullable=True),
+        sa.Column('roll_deg', sa.Float(precision=53), nullable=True),
+        sa.Column('rtk_fix', sa.Boolean(), nullable=True),
+        sa.Column('std_h_m', sa.Float(precision=53), nullable=True),
+        sa.Column('std_v_m', sa.Float(precision=53), nullable=True),
+        sa.Column('temp_caption_id', postgresql.UUID(as_uuid=True), nullable=True),
+        
+        sa.CheckConstraint('center_lat IS NULL OR (center_lat BETWEEN -90 AND 90)', name='chk_images_new_center_lat'),
+        sa.CheckConstraint('center_lon IS NULL OR (center_lon BETWEEN -180 AND 180)', name='chk_images_new_center_lon'),
+        sa.CheckConstraint('heading_deg IS NULL OR (heading_deg >= 0 AND heading_deg <= 360)', name='chk_images_new_heading_deg'),
+        sa.CheckConstraint('pitch_deg IS NULL OR (pitch_deg BETWEEN -90 AND 90)', name='chk_images_new_pitch_deg'),
+        sa.CheckConstraint('yaw_deg IS NULL OR (yaw_deg BETWEEN -180 AND 180)', name='chk_images_new_yaw_deg'),
+        sa.CheckConstraint('roll_deg IS NULL OR (roll_deg BETWEEN -180 AND 180)', name='chk_images_new_roll_deg'),
+    )
+
+    # Create new Captions table
+    op.create_table(
+        'captions',
+        sa.Column('caption_id', postgresql.UUID(as_uuid=True),
+                  server_default=sa.text('gen_random_uuid()'),
+                  primary_key=True),
+        sa.Column('title', sa.String(), nullable=True),
+        sa.Column('prompt', sa.String(), sa.ForeignKey('prompts.p_code'), nullable=True),
+        sa.Column('model', sa.String(), sa.ForeignKey('models.m_code'), nullable=True),
+        sa.Column('schema_id', sa.String(), sa.ForeignKey('json_schemas.schema_id'), nullable=True),
+        sa.Column('raw_json', postgresql.JSONB(astext_type=sa.Text()), nullable=True),
+        sa.Column('generated', sa.Text(), nullable=True),
+        sa.Column('edited', sa.Text(), nullable=True),
+        sa.Column('accuracy', sa.SmallInteger()),
+        sa.Column('context', sa.SmallInteger()),
+        sa.Column('usability', sa.SmallInteger()),
+        sa.Column('starred', sa.Boolean(), server_default=sa.text('false')),
+        sa.Column('created_at', sa.TIMESTAMP(timezone=True), server_default=sa.text('NOW()'), nullable=False),
+        sa.Column('updated_at', sa.TIMESTAMP(timezone=True), nullable=True),
+        
+        sa.CheckConstraint('accuracy IS NULL OR (accuracy BETWEEN 0 AND 100)', name='chk_captions_accuracy'),
+        sa.CheckConstraint('context IS NULL OR (context BETWEEN 0 AND 100)', name='chk_captions_context'),
+        sa.CheckConstraint('usability IS NULL OR (usability BETWEEN 0 AND 100)', name='chk_captions_usability')
+    )
+
+    # Create Images_captions junction table
+    op.create_table(
+        'images_captions',
+        sa.Column('image_id', postgresql.UUID(as_uuid=True), nullable=False),
+        sa.Column('caption_id', postgresql.UUID(as_uuid=True), nullable=False),
+        sa.PrimaryKeyConstraint('image_id', 'caption_id', name='pk_images_captions'),
+        sa.ForeignKeyConstraint(['image_id'], ['images_new.image_id'], ondelete='CASCADE'),
+        sa.ForeignKeyConstraint(['caption_id'], ['captions.caption_id'], ondelete='CASCADE')
+    )
+
+    # Add indexes for performance
+    op.create_index('ix_images_captions_image_id', 'images_captions', ['image_id'])
+    op.create_index('ix_images_captions_caption_id', 'images_captions', ['caption_id'])
+
+    # Migrate data from old images table to new structure with temporary caption_id
+    op.execute("""
+        INSERT INTO images_new (
+            image_id, file_key, sha256, source, event_type, epsg, image_type, captured_at,
+            center_lon, center_lat, amsl_m, agl_m, heading_deg, yaw_deg, pitch_deg, roll_deg, rtk_fix, std_h_m, std_v_m,
+            temp_caption_id
+        )
+        SELECT 
+            image_id, file_key, sha256, source, event_type, epsg, image_type, captured_at,
+            center_lon, center_lat, amsl_m, agl_m, heading_deg, yaw_deg, pitch_deg, roll_deg, rtk_fix, std_h_m, std_v_m,
+            CASE 
+                WHEN title IS NOT NULL OR prompt IS NOT NULL OR model IS NOT NULL OR schema_id IS NOT NULL
+                     OR raw_json IS NOT NULL OR generated IS NOT NULL OR edited IS NOT NULL
+                     OR accuracy IS NOT NULL OR context IS NOT NULL OR usability IS NOT NULL
+                     OR starred = true OR updated_at IS NOT NULL
+                THEN gen_random_uuid()
+                ELSE NULL
+            END as temp_caption_id
+        FROM images
+    """)
+
+    # Migrate caption data using the same temp_caption_id
+    op.execute("""
+        INSERT INTO captions (
+            caption_id, title, prompt, model, schema_id, raw_json, generated, edited,
+            accuracy, context, usability, starred, created_at, updated_at
+        )
+        SELECT 
+            i_new.temp_caption_id, i.title, i.prompt, i.model, i.schema_id, i.raw_json, i.generated, i.edited,
+            i.accuracy, i.context, i.usability, i.starred, i.created_at, i.updated_at
+        FROM images i
+        JOIN images_new i_new ON i.image_id = i_new.image_id
+        WHERE i_new.temp_caption_id IS NOT NULL
+    """)
+
+    # Create relationships using the temp_caption_id
+    op.execute("""
+        INSERT INTO images_captions (image_id, caption_id)
+        SELECT image_id, temp_caption_id
+        FROM images_new
+        WHERE temp_caption_id IS NOT NULL
+    """)
+
+    # Drop the temporary column
+    op.drop_column('images_new', 'temp_caption_id')
+
+    # Save image_countries data to temp table before dropping
+    op.execute("CREATE TEMP TABLE tmp_image_countries AS TABLE image_countries")
+    
+    # Drop old tables and constraints
+    op.drop_table('image_countries')
+    op.drop_index('ix_images_created_at', table_name='images', if_exists=True)
+    op.drop_table('images')
+
+    # Rename new table to 'images'
+    op.rename_table('images_new', 'images')
+
+    # Recreate image_countries table with new image_id reference
+    op.create_table(
+        'image_countries',
+        sa.Column('image_id', postgresql.UUID(as_uuid=True), nullable=False),
+        sa.Column('c_code', sa.CHAR(length=2), nullable=False),
+        sa.PrimaryKeyConstraint('image_id', 'c_code', name='pk_image_countries'),
+        sa.ForeignKeyConstraint(['image_id'], ['images.image_id'], ondelete='CASCADE'),
+        sa.ForeignKeyConstraint(['c_code'], ['countries.c_code'])
+    )
+
+    # Restore image_countries data
+    op.execute("""
+        INSERT INTO image_countries (image_id, c_code)
+        SELECT image_id, c_code FROM tmp_image_countries
+    """)
+
+    # Recreate index with proper name
+    op.create_index('ix_images_captured_at', 'images', ['captured_at'])
+
+def downgrade():
+    raise NotImplementedError("Downgrade not supported for 0016 - this is a structural table split")

py_backend/app/crud.py

@@ -1,5 +1,5 @@
 import io, hashlib
-from typing import Optional
+from typing import Optional, List
 from sqlalchemy.orm import Session, joinedload
 from . import models, schemas
 from fastapi import HTTPException
@@ -62,21 +62,23 @@ def create_image(db: Session, src, type_code, key, sha, countries: list[str], ep
     return img
 
 def get_images(db: Session):
-    """Get all images with their countries"""
+    """Get all images with their countries and captions"""
     return (
         db.query(models.Images)
         .options(
             joinedload(models.Images.countries),
+            joinedload(models.Images.captions),
         )
         .all()
     )
 
 def get_image(db: Session, image_id: str):
-    """Get a single image by ID with its countries"""
+    """Get a single image by ID with its countries and captions"""
     return (
         db.query(models.Images)
         .options(
             joinedload(models.Images.countries),
+            joinedload(models.Images.captions),
         )
         .filter(models.Images.image_id == image_id)
         .first()
@@ -100,35 +102,49 @@ def create_caption(db: Session, image_id, title, prompt, model_code, raw_json, t
     if img.image_type == "drone_image":
         schema_id = "drone_caption@1.0.0"
     
-    img.title = title
-    img.prompt = prompt
-    img.model = model_code
-    img.schema_id = schema_id
-    img.raw_json = raw_json
-    img.generated = text
-    img.edited = text
+    caption = models.Captions(
+        title=title,
+        prompt=prompt,
+        model=model_code,
+        schema_id=schema_id,
+        raw_json=raw_json,
+        generated=text,
+        edited=text
+    )
+    
+    db.add(caption)
+    db.flush()
+    
+    # Link caption to image
+    img.captions.append(caption)
     
     print(f"About to commit caption to database...")
     db.commit()
     print(f"Caption commit successful!")
-    db.refresh(img)
+    db.refresh(caption)
     print(f"Caption created successfully for image: {img.image_id}")
-    return img
+    return caption
 
-def get_caption(db: Session, image_id: str):
-    """Get caption data for a specific image"""
-    return db.get(models.Images, image_id)
+def get_caption(db: Session, caption_id: str):
+    """Get caption data for a specific caption ID"""
+    return db.get(models.Captions, caption_id)
 
 def get_captions_by_image(db: Session, image_id: str):
-    """Get caption data for a specific image (now just returns the image)"""
+    """Get all captions for a specific image"""
     img = db.get(models.Images, image_id)
-    if img and img.title:
-        return [img]
+    if img:
+        return img.captions
     return []
 
 def get_all_captions_with_images(db: Session):
-    """Get all images that have caption data"""
-    return db.query(models.Images).filter(models.Images.title.isnot(None)).all()
+    """Get all captions with their associated images"""
+    return (
+        db.query(models.Captions)
+        .options(
+            joinedload(models.Captions.images),
+        )
+        .all()
+    )
 
 def get_prompts(db: Session):
     """Get all available prompts"""
@@ -253,37 +269,26 @@ def update_prompt(db: Session, p_code: str, prompt_update: schemas.PromptUpdate)
     db.refresh(prompt)
     return prompt
 
-def update_caption(db: Session, image_id: str, update: schemas.CaptionUpdate):
-    """Update caption data for an image"""
-    img = db.get(models.Images, image_id)
-    if not img:
+def update_caption(db: Session, caption_id: str, update: schemas.CaptionUpdate):
+    """Update caption data for a caption"""
+    caption = db.get(models.Captions, caption_id)
+    if not caption:
         return None
     
     for field, value in update.dict(exclude_unset=True).items():
-        setattr(img, field, value)
+        setattr(caption, field, value)
     
     db.commit()
-    db.refresh(img)
-    return img
+    db.refresh(caption)
+    return caption
 
-def delete_caption(db: Session, image_id: str):
-    """Delete caption data for an image (sets caption fields to None)"""
-    img = db.get(models.Images, image_id)
-    if not img:
+def delete_caption(db: Session, caption_id: str):
+    """Delete caption data for a caption"""
+    caption = db.get(models.Captions, caption_id)
+    if not caption:
         return False
     
-    img.title = None
-    img.prompt = None
-    img.model = None
-    img.schema_id = None
-    img.raw_json = None
-    img.generated = None
-    img.edited = None
-    img.accuracy = None
-    img.context = None
-    img.usability = None
-    img.starred = False
-    
+    db.delete(caption)
     db.commit()
     return True
 
@@ -373,4 +378,4 @@ def get_schema(db: Session, schema_id: str):
 
 def get_recent_images_with_validation(db: Session, limit: int = 100):
     """Get recent images with validation info"""
-    return db.query(models.Images).order_by(models.Images.created_at.desc()).limit(limit).all()
+    return db.query(models.Images).order_by(models.Images.captured_at.desc()).limit(limit).all()

py_backend/app/models.py

@@ -24,6 +24,22 @@ image_countries = Table(
     ),
 )
 
+images_captions = Table(
+    "images_captions", Base.metadata,
+    Column(
+      "image_id",
+      UUID(as_uuid=True),
+      ForeignKey("images.image_id", ondelete="CASCADE"),
+      primary_key=True,
+    ),
+    Column(
+      "caption_id",
+      UUID(as_uuid=True),
+      ForeignKey("captions.caption_id", ondelete="CASCADE"),
+      primary_key=True,
+    ),
+)
+
 class Source(Base):
     __tablename__ = "sources"
     s_code = Column(String, primary_key=True)
@@ -90,9 +106,12 @@ class JSONSchema(Base):
 class Images(Base):
     __tablename__ = "images"
     __table_args__ = (
-        CheckConstraint('accuracy  IS NULL OR (accuracy  BETWEEN 0 AND 100)', name='chk_images_accuracy'),
-        CheckConstraint('context   IS NULL OR (context   BETWEEN 0 AND 100)', name='chk_images_context'),
-        CheckConstraint('usability IS NULL OR (usability BETWEEN 0 AND 100)', name='chk_images_usability'),
+        CheckConstraint('center_lat IS NULL OR (center_lat BETWEEN -90 AND 90)', name='chk_images_center_lat'),
+        CheckConstraint('center_lon IS NULL OR (center_lon BETWEEN -180 AND 180)', name='chk_images_center_lon'),
+        CheckConstraint('heading_deg IS NULL OR (heading_deg >= 0 AND heading_deg <= 360)', name='chk_images_heading_deg'),
+        CheckConstraint('pitch_deg IS NULL OR (pitch_deg BETWEEN -90 AND 90)', name='chk_images_pitch_deg'),
+        CheckConstraint('yaw_deg IS NULL OR (yaw_deg BETWEEN -180 AND 180)', name='chk_images_yaw_deg'),
+        CheckConstraint('roll_deg IS NULL OR (roll_deg BETWEEN -180 AND 180)', name='chk_images_roll_deg'),
     )
 
     image_id    = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
@@ -102,27 +121,9 @@ class Images(Base):
     event_type  = Column(String, ForeignKey("event_types.t_code"), nullable=False)
     epsg        = Column(String, ForeignKey("spatial_references.epsg"), nullable=False)
     image_type  = Column(String, ForeignKey("image_types.image_type"), nullable=False)
-    created_at  = Column(TIMESTAMP(timezone=True), default=datetime.datetime.utcnow)
     captured_at = Column(TIMESTAMP(timezone=True))
 
-    title      = Column(String, nullable=True)
-    prompt     = Column(String, ForeignKey("prompts.p_code"), nullable=True)
-    model      = Column(String, ForeignKey("models.m_code"), nullable=True)
-    schema_id  = Column(String, ForeignKey("json_schemas.schema_id"), nullable=True)
-    raw_json   = Column(JSONB, nullable=True)
-    generated  = Column(Text, nullable=True)
-    edited     = Column(Text)
-    accuracy   = Column(SmallInteger)
-    context    = Column(SmallInteger)
-    usability  = Column(SmallInteger)
-    starred    = Column(Boolean, default=False)
-    updated_at = Column(TIMESTAMP(timezone=True), onupdate=datetime.datetime.utcnow)
-
-    countries = relationship("Country", secondary=image_countries, backref="images")
-    schema    = relationship("JSONSchema")
-    model_r   = relationship("Models", foreign_keys=[model])
-    prompt_r  = relationship("Prompts", foreign_keys=[prompt])
-
+    # Drone-specific fields
     center_lon = Column(Float)   
     center_lat = Column(Float)
     amsl_m     = Column(Float)
@@ -134,3 +135,35 @@ class Images(Base):
     rtk_fix    = Column(Boolean)
     std_h_m    = Column(Float)
     std_v_m    = Column(Float)
+
+    # Relationships
+    countries = relationship("Country", secondary=image_countries, backref="images")
+    captions = relationship("Captions", secondary=images_captions, backref="images")
+
+class Captions(Base):
+    __tablename__ = "captions"
+    __table_args__ = (
+        CheckConstraint('accuracy IS NULL OR (accuracy BETWEEN 0 AND 100)', name='chk_captions_accuracy'),
+        CheckConstraint('context IS NULL OR (context BETWEEN 0 AND 100)', name='chk_captions_context'),
+        CheckConstraint('usability IS NULL OR (usability BETWEEN 0 AND 100)', name='chk_captions_usability'),
+    )
+
+    caption_id  = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    title       = Column(String, nullable=True)
+    prompt      = Column(String, ForeignKey("prompts.p_code"), nullable=True)
+    model       = Column(String, ForeignKey("models.m_code"), nullable=True)
+    schema_id   = Column(String, ForeignKey("json_schemas.schema_id"), nullable=True)
+    raw_json    = Column(JSONB, nullable=True)
+    generated   = Column(Text, nullable=True)
+    edited      = Column(Text)
+    accuracy    = Column(SmallInteger)
+    context     = Column(SmallInteger)
+    usability   = Column(SmallInteger)
+    starred     = Column(Boolean, default=False)
+    created_at  = Column(TIMESTAMP(timezone=True), default=datetime.datetime.utcnow)
+    updated_at  = Column(TIMESTAMP(timezone=True), onupdate=datetime.datetime.utcnow)
+
+    # Relationships
+    schema = relationship("JSONSchema")
+    model_r = relationship("Models", foreign_keys=[model])
+    prompt_r = relationship("Prompts", foreign_keys=[prompt])

py_backend/app/routers/admin.py

@@ -290,13 +290,13 @@ async def delete_model(
                 detail=f"Model '{model_code}' not found"
             )
         
-        # Check if model is being used by any images
-        from ..models import Images
-        image_count = db.query(Images).filter(Images.model == model_code).count()
-        if image_count > 0:
+        # Check if model is being used by any captions
+        from ..models import Captions
+        caption_count = db.query(Captions).filter(Captions.model == model_code).count()
+        if caption_count > 0:
             raise HTTPException(
                 status_code=400,
-                detail=f"Cannot delete model '{model_code}' - it is used by {image_count} image(s)"
+                detail=f"Cannot delete model '{model_code}' - it is used by {caption_count} caption(s)"
             )
         
         # Hard delete model (remove from database)

py_backend/app/routers/caption.py

@@ -82,7 +82,7 @@ def get_db():
 
 @router.post(
     "/images/{image_id}/caption",
-    response_model=schemas.ImageOut,
+    response_model=schemas.CaptionOut,
 )
 async def create_caption(
     image_id: str,
@@ -205,7 +205,7 @@ async def create_caption(
         raw = {"error": str(e), "fallback": True}
         metadata = {}
 
-    c = crud.create_caption(
+    caption = crud.create_caption(
         db,
         image_id=image_id,
         title=title,
@@ -216,141 +216,170 @@ async def create_caption(
         metadata=metadata,
     )
     
-    db.refresh(c)
-    
-    print(f"DEBUG: Caption created, image object: {c}")
-    print(f"DEBUG: file_key: {c.file_key}")
-    print(f"DEBUG: image_id: {c.image_id}")
-    
-    from .upload import convert_image_to_dict
-    try:
-        url = storage.get_object_url(c.file_key)
-        print(f"DEBUG: Generated URL: {url}")
-        if url.startswith('/') and settings.STORAGE_PROVIDER == "local":
-            url = f"http://localhost:8000{url}"
-            print(f"DEBUG: Local URL adjusted to: {url}")
-    except Exception as e:
-        print(f"DEBUG: URL generation failed: {e}")
-        url = f"/api/images/{c.image_id}/file"
-        print(f"DEBUG: Using fallback URL: {url}")
-    
-    img_dict = convert_image_to_dict(c, url)
-    return schemas.ImageOut(**img_dict)
-
-@router.get(
-    "/images/{image_id}/caption",
-    response_model=schemas.ImageOut,
-)
-def get_caption(
-    image_id: str,
-    db: Session = Depends(get_db),
-):
-    caption = crud.get_caption(db, image_id)
-    if not caption or not caption.title:
-        raise HTTPException(404, "caption not found")
-    
     db.refresh(caption)
     
-    from .upload import convert_image_to_dict
-    try:
-        url = storage.get_object_url(caption.file_key)
-        if url.startswith('/') and settings.STORAGE_PROVIDER == "local":
-            url = f"http://localhost:8000{url}"
-    except Exception:
-        url = f"/api/images/{caption.image_id}/file"
+    print(f"DEBUG: Caption created, caption object: {caption}")
+    print(f"DEBUG: caption_id: {caption.caption_id}")
     
-    img_dict = convert_image_to_dict(caption, url)
-    return schemas.ImageOut(**img_dict)
+    return schemas.CaptionOut.from_orm(caption)
 
 @router.get(
-    "/images/{image_id}/captions",
+    "/captions/legacy",
     response_model=List[schemas.ImageOut],
 )
-def get_captions_by_image(
-    image_id: str,
+def get_all_captions_legacy_format(
     db: Session = Depends(get_db),
 ):
-    """Get caption data for a specific image"""
-    captions = crud.get_captions_by_image(db, image_id)
+    """Get all images with captions in the old format for backward compatibility"""
+    print(f"DEBUG: Fetching all captions in legacy format...")
+    captions = crud.get_all_captions_with_images(db)
+    print(f"DEBUG: Found {len(captions)} captions")
     
-    from .upload import convert_image_to_dict
     result = []
     for caption in captions:
         db.refresh(caption)
         
-        try:
-            url = storage.get_object_url(caption.file_key)
-        except Exception:
-            url = f"/api/images/{caption.image_id}/file"
-        
-        img_dict = convert_image_to_dict(caption, url)
-        result.append(schemas.ImageOut(**img_dict))
+        # Get the associated image for this caption
+        if caption.images:
+            for image in caption.images:
+                # Create a response in the old format where caption data is embedded in image
+                from .upload import convert_image_to_dict
+                try:
+                    url = storage.get_object_url(image.file_key)
+                    if url.startswith('/') and settings.STORAGE_PROVIDER == "local":
+                        url = f"http://localhost:8000{url}"
+                except Exception:
+                    url = f"/api/images/{image.image_id}/file"
+                
+                img_dict = convert_image_to_dict(image, url)
+                
+                # Override with caption data
+                img_dict.update({
+                    "title": caption.title,
+                    "prompt": caption.prompt,
+                    "model": caption.model,
+                    "schema_id": caption.schema_id,
+                    "raw_json": caption.raw_json,
+                    "generated": caption.generated,
+                    "edited": caption.edited,
+                    "accuracy": caption.accuracy,
+                    "context": caption.context,
+                    "usability": caption.usability,
+                    "starred": caption.starred,
+                    "created_at": caption.created_at,
+                    "updated_at": caption.updated_at,
+                })
+                
+                result.append(schemas.ImageOut(**img_dict))
     
+    print(f"DEBUG: Returning {len(result)} legacy format results")
     return result
 
 @router.get(
     "/captions",
-    response_model=List[schemas.ImageOut],
+    response_model=List[schemas.CaptionOut],
 )
 def get_all_captions_with_images(
     db: Session = Depends(get_db),
 ):
-    """Get all images that have caption data"""
-    print(f"DEBUG: Fetching all captions with images...")
+    """Get all captions"""
+    print(f"DEBUG: Fetching all captions...")
     captions = crud.get_all_captions_with_images(db)
-    print(f"DEBUG: Found {len(captions)} images with caption data")
+    print(f"DEBUG: Found {len(captions)} captions")
     
-    from .upload import convert_image_to_dict
     result = []
     for caption in captions:
-        print(f"DEBUG: Processing image {caption.image_id}, title: {caption.title}, generated: {caption.generated}, model: {caption.model}")
+        print(f"DEBUG: Processing caption {caption.caption_id}, title: {caption.title}, generated: {caption.generated}, model: {caption.model}")
         
         db.refresh(caption)
-        
-        try:
-            url = storage.get_object_url(caption.file_key)
-        except Exception:
-            url = f"/api/images/{caption.image_id}/file"
-        
-        img_dict = convert_image_to_dict(caption, url)
-        result.append(schemas.ImageOut(**img_dict))
+        result.append(schemas.CaptionOut.from_orm(caption))
     
     print(f"DEBUG: Returning {len(result)} formatted results")
     return result
 
+@router.get(
+    "/images/{image_id}/captions",
+    response_model=List[schemas.CaptionOut],
+)
+def get_captions_by_image(
+    image_id: str,
+    db: Session = Depends(get_db),
+):
+    """Get all captions for a specific image"""
+    captions = crud.get_captions_by_image(db, image_id)
+    
+    result = []
+    for caption in captions:
+        db.refresh(caption)
+        result.append(schemas.CaptionOut.from_orm(caption))
+    
+    return result
+
+@router.get(
+    "/captions/{caption_id}",
+    response_model=schemas.CaptionOut,
+)
+def get_caption(
+    caption_id: str,
+    db: Session = Depends(get_db),
+):
+    caption = crud.get_caption(db, caption_id)
+    if not caption:
+        raise HTTPException(404, "caption not found")
+    
+    db.refresh(caption)
+    return schemas.CaptionOut.from_orm(caption)
+
 @router.put(
-    "/images/{image_id}/caption",
-    response_model=schemas.ImageOut,
+    "/captions/{caption_id}",
+    response_model=schemas.CaptionOut,
 )
 def update_caption(
-    image_id: str,
+    caption_id: str,
     update: schemas.CaptionUpdate,
     db: Session = Depends(get_db),
 ):
-    caption = crud.update_caption(db, image_id, update)
+    caption = crud.update_caption(db, caption_id, update)
     if not caption:
         raise HTTPException(404, "caption not found")
     
     db.refresh(caption)
+    return schemas.CaptionOut.from_orm(caption)
+
+@router.put(
+    "/images/{image_id}/caption",
+    response_model=schemas.CaptionOut,
+)
+def update_caption_by_image(
+    image_id: str,
+    update: schemas.CaptionUpdate,
+    db: Session = Depends(get_db),
+):
+    """Update the first caption for an image (for backward compatibility)"""
+    img = crud.get_image(db, image_id)
+    if not img:
+        raise HTTPException(404, "image not found")
     
-    from .upload import convert_image_to_dict
-    try:
-        url = storage.get_object_url(caption.file_key)
-    except Exception:
-        url = f"/api/images/{caption.image_id}/file"
+    if not img.captions:
+        raise HTTPException(404, "no captions found for this image")
     
-    img_dict = convert_image_to_dict(caption, url)
-    return schemas.ImageOut(**img_dict)
+    # Update the first caption
+    caption = crud.update_caption(db, str(img.captions[0].caption_id), update)
+    if not caption:
+        raise HTTPException(404, "caption not found")
+    
+    db.refresh(caption)
+    return schemas.CaptionOut.from_orm(caption)
 
 @router.delete(
-    "/images/{image_id}/caption",
+    "/captions/{caption_id}",
 )
 def delete_caption(
-    image_id: str,
+    caption_id: str,
     db: Session = Depends(get_db),
 ):
-    """Delete caption data for an image"""
-    success = crud.delete_caption(db, image_id)
+    """Delete caption data for a caption"""
+    success = crud.delete_caption(db, caption_id)
     if not success:
         raise HTTPException(404, "caption not found")
     return {"message": "Caption deleted successfully"}

py_backend/app/routers/images.py

@@ -153,17 +153,6 @@ async def create_image_from_url(payload: CreateImageFromUrlIn, db: Session = Dep
             event_type=event_type,
             epsg=epsg,
             image_type=payload.image_type,
-            title="no title",
-            prompt=prompt_code,
-            model="STUB_MODEL",
-            schema_id=schema_id,
-            raw_json={},
-            generated="",
-            edited="",
-            accuracy=50,
-            context=50,
-            usability=50,
-            starred=False,
             center_lon=payload.center_lon,
             center_lat=payload.center_lat,
             amsl_m=payload.amsl_m,
@@ -219,7 +208,8 @@ async def debug_database_status(db: Session = Depends(get_db)):
         # Check required tables
         tables_to_check = [
             "sources", "event_types", "spatial_references", "image_types",
-            "prompts", "models", "json_schemas", "images", "image_countries"
+            "prompts", "models", "json_schemas", "images", "image_countries",
+            "captions", "images_captions"
         ]
         
         for table in tables_to_check:

py_backend/app/routers/metadata.py

@@ -12,16 +12,16 @@ def get_db():
     finally:
         db.close()
 
-@router.put("/maps/{map_id}/metadata", response_model=schemas.ImageOut)
+@router.put("/captions/{caption_id}/metadata", response_model=schemas.CaptionOut)
 def update_metadata(
-    map_id: str,
+    caption_id: str,
     update: schemas.CaptionUpdate,
     db: Session = Depends(get_db)
 ):
-    c = crud.update_caption(db, map_id, update)
-    if not c:
+    caption = crud.update_caption(db, caption_id, update)
+    if not caption:
         raise HTTPException(404, "caption not found")
-    return c
+    return schemas.CaptionOut.from_orm(caption)
 
 @router.get("/sources", response_model=List[schemas.SourceOut])
 def get_sources(db: Session = Depends(get_db)):

py_backend/app/routers/upload.py

@@ -9,6 +9,7 @@ from typing import List, Optional
 import boto3
 import time
 import base64
+import datetime
 
 router = APIRouter()
 
@@ -50,6 +51,62 @@ def convert_image_to_dict(img, image_url):
             print(f"Warning: Error processing countries for image {img.image_id}: {e}")
             countries_list = []
     
+    captions_list = []
+    if hasattr(img, 'captions') and img.captions is not None:
+        try:
+            captions_list = [
+                {
+                    "caption_id": c.caption_id,
+                    "title": c.title,
+                    "prompt": c.prompt,
+                    "model": c.model,
+                    "schema_id": c.schema_id,
+                    "raw_json": c.raw_json,
+                    "generated": c.generated,
+                    "edited": c.edited,
+                    "accuracy": c.accuracy,
+                    "context": c.context,
+                    "usability": c.usability,
+                    "starred": c.starred if c.starred is not None else False,
+                    "created_at": c.created_at,
+                    "updated_at": c.updated_at
+                } for c in img.captions
+            ]
+        except Exception as e:
+            print(f"Warning: Error processing captions for image {img.image_id}: {e}")
+            captions_list = []
+    
+    # Get starred status and other caption fields from first caption for backward compatibility
+    starred = False
+    title = None
+    prompt = None
+    model = None
+    schema_id = None
+    raw_json = None
+    generated = None
+    edited = None
+    accuracy = None
+    context = None
+    usability = None
+    created_at = None
+    updated_at = None
+    
+    if captions_list:
+        first_caption = captions_list[0]
+        starred = first_caption.get("starred", False)
+        title = first_caption.get("title")
+        prompt = first_caption.get("prompt")
+        model = first_caption.get("model")
+        schema_id = first_caption.get("schema_id")
+        raw_json = first_caption.get("raw_json")
+        generated = first_caption.get("generated")
+        edited = first_caption.get("edited")
+        accuracy = first_caption.get("accuracy")
+        context = first_caption.get("context")
+        usability = first_caption.get("usability")
+        created_at = first_caption.get("created_at")
+        updated_at = first_caption.get("updated_at")
+    
     img_dict = {
         "image_id": img.image_id,
         "file_key": img.file_key,
@@ -60,19 +117,23 @@ def convert_image_to_dict(img, image_url):
         "image_type": img.image_type,
         "image_url": image_url,
         "countries": countries_list,
-        "title": img.title,
-        "prompt": img.prompt,
-        "model": img.model,
-        "schema_id": img.schema_id,
-        "raw_json": img.raw_json,
-        "generated": img.generated,
-        "edited": img.edited,
-        "accuracy": img.accuracy,
-        "context": img.context,
-        "usability": img.usability,
-        "starred": img.starred if img.starred is not None else False,
-        "created_at": img.created_at,
-        "updated_at": img.updated_at,
+        "captions": captions_list,
+        "starred": starred,  # Backward compatibility
+        "captured_at": img.captured_at,
+        
+        # Backward compatibility fields for legacy frontend
+        "title": title,
+        "prompt": prompt,
+        "model": model,
+        "schema_id": schema_id,
+        "raw_json": raw_json,
+        "generated": generated,
+        "edited": edited,
+        "accuracy": accuracy,
+        "context": context,
+        "usability": usability,
+        "created_at": created_at,
+        "updated_at": updated_at,
         
         # Drone-specific fields
         "center_lon": getattr(img, 'center_lon', None),
@@ -367,8 +428,21 @@ def update_image_metadata(
             img.epsg = metadata.epsg
         if metadata.image_type is not None:
             img.image_type = metadata.image_type
+        # Handle starred field - update the first caption's starred status
         if metadata.starred is not None:
-            img.starred = metadata.starred
+            if img.captions:
+                # Update the first caption's starred status
+                img.captions[0].starred = metadata.starred
+            else:
+                # If no captions exist, create a minimal caption with starred status
+                from app import models
+                caption = models.Captions(
+                    title="",
+                    starred=metadata.starred,
+                    created_at=datetime.datetime.utcnow()
+                )
+                db.add(caption)
+                img.captions.append(caption)
         
         # Update drone-specific fields
         if metadata.center_lon is not None:
@@ -435,12 +509,15 @@ def delete_image(image_id: str, db: Session = Depends(get_db), content_managemen
     
     # Only increment delete count if this is NOT a content management delete
     # Content management deletes (from map details) should not count against model performance
-    if not content_management and img.model:
-        from .. import crud as crud_module
-        model = crud_module.get_model(db, img.model)
-        if model:
-            model.delete_count += 1
-            db.commit()
+    if not content_management and img.captions:
+        # Get model from the first caption
+        model_name = img.captions[0].model
+        if model_name:
+            from .. import crud as crud_module
+            model = crud_module.get_model(db, model_name)
+            if model:
+                model.delete_count += 1
+                db.commit()
     
     db.delete(img)
     db.commit()

py_backend/app/schemas.py

@@ -29,7 +29,7 @@ class ImageMetadataUpdate(BaseModel):
     countries: Optional[List[str]] = None
     epsg: Optional[str] = None
     image_type: Optional[str] = None
-    starred: Optional[bool] = None
+    starred: Optional[bool] = None  # Backward compatibility - updates first caption
     
     # Drone-specific fields (optional)
     center_lon: Optional[float] = None
@@ -44,6 +44,25 @@ class ImageMetadataUpdate(BaseModel):
     std_h_m: Optional[float] = None
     std_v_m: Optional[float] = None
 
+class CaptionOut(BaseModel):
+    caption_id: UUID
+    title: Optional[str] = None
+    prompt: Optional[str] = None
+    model: Optional[str] = None
+    schema_id: Optional[str] = None
+    raw_json: Optional[dict] = None
+    generated: Optional[str] = None
+    edited: Optional[str] = None
+    accuracy: Optional[int] = None
+    context: Optional[int] = None
+    usability: Optional[int] = None
+    starred: bool = False
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True
+
 class ImageOut(BaseModel):
     image_id: UUID
     file_key: str
@@ -54,6 +73,11 @@ class ImageOut(BaseModel):
     image_type: str
     image_url: str
     countries: List["CountryOut"] = []
+    captions: List[CaptionOut] = []
+    starred: bool = False  # Backward compatibility - from first caption
+    captured_at: Optional[datetime] = None
+    
+    # Backward compatibility fields for legacy frontend
     title: Optional[str] = None
     prompt: Optional[str] = None
     model: Optional[str] = None
@@ -64,7 +88,6 @@ class ImageOut(BaseModel):
     accuracy: Optional[int] = None
     context: Optional[int] = None
     usability: Optional[int] = None
-    starred: bool = False
     created_at: Optional[datetime] = None
     updated_at: Optional[datetime] = None
     
@@ -94,6 +117,18 @@ class CaptionUpdate(BaseModel):
     context: Optional[int] = None
     usability: Optional[int] = None
 
+class CaptionCreate(BaseModel):
+    title: str
+    prompt: str
+    model: str
+    raw_json: dict
+    generated: str
+    edited: str
+    accuracy: Optional[int] = None
+    context: Optional[int] = None
+    usability: Optional[int] = None
+    starred: bool = False
+
 class PromptOut(BaseModel):
     p_code: str
     label: str

py_backend/tests/integration_tests/test_explore_page.py

@@ -163,8 +163,8 @@ def test_database_consistency():
         images = db.query(models.Images).all()
         print(f"  + Total images in database: {len(images)}")
         
-        images_with_captions = db.query(models.Images).filter(models.Images.title.isnot(None)).all()
-        print(f"  + Images with caption data: {len(images_with_captions)}")
+        captions = db.query(models.Captions).all()
+        print(f"  + Total captions in database: {len(captions)}")
         
         sources = db.query(models.Source).all()
         print(f"  + Total sources: {len(sources)}")

py_backend/tests/integration_tests/test_upload_flow.py

@@ -27,13 +27,7 @@ def test_database_connection():
             source="OTHER",
             event_type="OTHER",
             epsg="4326",
-            image_type="crisis_map",
-            title="Test Title",
-            prompt="Test prompt",
-            model="STUB_MODEL",
-            schema_id="default_caption@1.0.0",
-            raw_json={"test": True},
-            generated="This is a test caption"
+            image_type="crisis_map"
         )
         
         db.add(test_img)