revert

py_backend/app/routers/caption.py

@@ -44,11 +44,7 @@ if settings.HF_API_KEY:
         try:
             models = crud.get_models(db)
             for model in models:
-               
-                if (model.provider == "huggingface" and 
-                    model.model_id and 
-                    model.m_code != "STUB_MODEL" and
-                    model.m_code not in ["GPT-4O", "GEMINI15"]):  
+                if model.provider == "huggingface" and model.model_id and model.m_code != "STUB_MODEL":
                     try:
                         service = ProvidersGenericVLMService(
                             api_key=settings.HF_API_KEY,
@@ -92,22 +88,30 @@ async def create_caption(
     model_name: str | None = Form(None),
     db: Session = Depends(get_db),
 ):
-    print(f"📝 Caption Router: Starting caption generation for image {image_id}")
-    print(f"📝 Caption Router: Requested model: {model_name}")
+    print(f"DEBUG: Received request - image_id: {image_id}, title: {title}, prompt: {prompt}, model_name: {model_name}")
     
-    # Get the image
     img = crud.get_image(db, image_id)
     if not img:
-        print(f"❌ Caption Router: Image {image_id} not found")
-        raise HTTPException(404, f"Image {image_id} not found")
-    
-    # Get the prompt object
+        raise HTTPException(404, "image not found")
+
+
+    print(f"Looking for prompt: '{prompt}' (type: {type(prompt)})")
+
     prompt_obj = crud.get_prompt(db, prompt)
+    
+    if not prompt_obj:
+        print(f"Prompt not found by code, trying to find by label...")
+        prompt_obj = crud.get_prompt_by_label(db, prompt)
+    
+    print(f"Prompt lookup result: {prompt_obj}")
     if not prompt_obj:
-        print(f"❌ Caption Router: Prompt '{prompt}' not found")
         raise HTTPException(400, f"Prompt '{prompt}' not found")
     
-    # Get image bytes
+    prompt_text = prompt_obj.label
+    metadata_instructions = prompt_obj.metadata_instructions or ""
+    print(f"Using prompt text: '{prompt_text}'")
+    print(f"Using metadata instructions: '{metadata_instructions[:100]}...'")
+
     try:
         if hasattr(storage, 's3') and settings.STORAGE_PROVIDER != "local":
             response = storage.s3.get_object(
@@ -121,73 +125,75 @@ async def create_caption(
             with open(file_path, 'rb') as f:
                 img_bytes = f.read()
     except Exception as e:
-        print(f"❌ Caption Router: Failed to get image bytes: {e}")
-        raise HTTPException(500, f"Failed to get image: {e}")
-    
-    # Prepare metadata instructions
-    metadata_instructions = ""
-    if img.image_type == "drone_image":
-        metadata_instructions = f"Image type: drone image. Center coordinates: {img.center_lon}, {img.center_lat}. Altitude: {img.amsl_m}m AMSL, {img.agl_m}m AGL. Heading: {img.heading_deg}°, Yaw: {img.yaw_deg}°, Pitch: {img.pitch_deg}°, Roll: {img.roll_deg}°. RTK fix: {img.rtk_fix}. Standard deviations: H={img.std_h_m}m, V={img.std_v_m}m."
-    else:
-        metadata_instructions = f"Image type: crisis map. Source: {img.source}. Event type: {img.event_type}. EPSG: {img.epsg}. Countries: {img.countries}."
-    
-    print(f"📝 Caption Router: Calling VLM manager...")
-    
-    # Call VLM manager
+        print(f"Error reading image file: {e}")
+        try:
+            url = storage.get_object_url(img.file_key)
+            if url.startswith('/') and settings.STORAGE_PROVIDER == "local":
+                url = f"http://localhost:8000{url}"
+            import requests
+            resp = requests.get(url)
+            resp.raise_for_status()
+            img_bytes = resp.content
+        except Exception as fallback_error:
+            print(f"Fallback also failed: {fallback_error}")
+            raise HTTPException(500, f"Could not read image file: {e}")
+
+    metadata = {}
     try:
         result = await vlm_manager.generate_caption(
-            image_bytes=img_bytes, 
-            prompt=prompt_obj.label,
+            image_bytes=img_bytes,
+            prompt=prompt_text,
             metadata_instructions=metadata_instructions,
             model_name=model_name,
             db_session=db,
         )
+        
+        # Get the raw response for validation
+        raw = result.get("raw_response", {})
+        
+        # Validate and clean the data using schema validation
+        image_type = img.image_type
+        print(f"DEBUG: Validating data for image type: {image_type}")
+        print(f"DEBUG: Raw data structure: {list(raw.keys()) if isinstance(raw, dict) else 'Not a dict'}")
+        
+        cleaned_data, is_valid, validation_error = schema_validator.clean_and_validate_data(raw, image_type)
+        
+        if is_valid:
+            print(f"✓ Schema validation passed for {image_type}")
+            text = cleaned_data.get("analysis", "")
+            metadata = cleaned_data.get("metadata", {})
+        else:
+            print(f"⚠ Schema validation failed for {image_type}: {validation_error}")
+            # Use fallback but log the validation error
+            text = result.get("caption", "This is a fallback caption due to schema validation error.")
+            metadata = result.get("metadata", {})
+            raw["validation_error"] = validation_error
+            raw["validation_failed"] = True
+        
+        # Use the actual model that was used, not the requested model_name
+        used_model = result.get("model", model_name) or "STUB_MODEL"
+        
+        # Check if fallback was used
+        fallback_used = result.get("fallback_used", False)
+        original_model = result.get("original_model", None)
+        fallback_reason = result.get("fallback_reason", None)
+        
+        if fallback_used:
+            print(f"⚠ Model fallback occurred: {original_model} -> {used_model} (reason: {fallback_reason})")
+            # Add fallback info to raw response for frontend
+            raw["fallback_info"] = {
+                "original_model": original_model,
+                "fallback_model": used_model,
+                "reason": fallback_reason
+            }
+        
     except Exception as e:
-        print(f"❌ Caption Router: VLM manager failed: {e}")
-        raise HTTPException(500, f"Caption generation failed: {e}")
-    
-    print(f"📝 Caption Router: VLM manager returned result")
-    
-    # Get the raw response for validation
-    raw = result.get("raw_response", {})
-    
-    # Validate and clean the data using schema validation
-    image_type = img.image_type
-    print(f"📝 Caption Router: Validating data for image type: {image_type}")
-    
-    cleaned_data, is_valid, validation_error = schema_validator.clean_and_validate_data(raw, image_type)
-    
-    if is_valid:
-        print(f"✅ Caption Router: Schema validation passed for {image_type}")
-        text = cleaned_data.get("analysis", "")
-        metadata = cleaned_data.get("metadata", {})
-    else:
-        print(f"⚠️ Caption Router: Schema validation failed for {image_type}: {validation_error}")
-        # Use fallback but log the validation error
-        text = result.get("caption", "This is a fallback caption due to schema validation error.")
-        metadata = result.get("metadata", {})
-        raw["validation_error"] = validation_error
-        raw["validation_failed"] = True
-    
-    # Use the actual model that was used, not the requested model_name
-    used_model = result.get("model", model_name) or "STUB_MODEL"
-    
-    # Check if fallback was used
-    fallback_used = result.get("fallback_used", False)
-    original_model = result.get("original_model", None)
-    fallback_reason = result.get("fallback_reason", None)
-    
-    if fallback_used:
-        print(f"⚠️ Caption Router: Model fallback occurred: {original_model} -> {used_model} (reason: {fallback_reason})")
-        # Add fallback info to raw response for frontend
-        raw["fallback_info"] = {
-            "original_model": original_model,
-            "fallback_model": used_model,
-            "reason": fallback_reason
-        }
-    
-    print(f"📝 Caption Router: Creating caption in database...")
-    
+        print(f"VLM error, using fallback: {e}")
+        text = "This is a fallback caption due to VLM service error."
+        used_model = "STUB_MODEL"
+        raw = {"error": str(e), "fallback": True}
+        metadata = {}
+
     c = crud.create_caption(
         db,
         image_id=image_id,
@@ -201,18 +207,23 @@ async def create_caption(
     
     db.refresh(c)
     
-    print(f"📝 Caption Router: Caption created successfully")
+    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)
-    print(f"📝 Caption Router: Caption generation completed successfully")
     return schemas.ImageOut(**img_dict)
 
 @router.get(

py_backend/app/services/gemini_service.py

@@ -20,10 +20,6 @@ class GeminiService(VLMService):
 
     async def generate_caption(self, image_bytes: bytes, prompt: str, metadata_instructions: str = "") -> Dict[str, Any]:
         """Generate caption using Google Gemini Vision"""
-        print(f"🔍 Gemini: Starting caption generation for {len(image_bytes)} bytes")
-        print(f"🔍 Gemini: Prompt: {prompt[:100]}...")
-        print(f"🔍 Gemini: Metadata instructions: {metadata_instructions[:100]}...")
-        
         instruction = prompt + "\n\n" + metadata_instructions
 
         image_part = {
@@ -32,70 +28,37 @@ class GeminiService(VLMService):
         }
 
         start = time.time()
-        try:
-            print(f"🔍 Gemini: Calling Google Gemini API with model: {self.model_id}")
-            response = await asyncio.to_thread(self.model.generate_content, [instruction, image_part])
-            elapsed = time.time() - start
-            
-            print(f"🔍 Gemini: API call successful, response received")
-            content = getattr(response, "text", None) or ""
-            print(f"🔍 Gemini: Raw content length: {len(content)}")
-            print(f"🔍 Gemini: Content preview: {content[:200]}...")
+        response = await asyncio.to_thread(self.model.generate_content, [instruction, image_part])
+        elapsed = time.time() - start
+
+        content = getattr(response, "text", None) or ""
 
-            cleaned_content = content
-            if cleaned_content.startswith("```json"):
-                cleaned_content = re.sub(r"^```json\s*", "", cleaned_content)
-                cleaned_content = re.sub(r"\s*```$", "", cleaned_content)
+        cleaned_content = content
+        if cleaned_content.startswith("```json"):
+            cleaned_content = re.sub(r"^```json\s*", "", cleaned_content)
+            cleaned_content = re.sub(r"\s*```$", "", cleaned_content)
 
-            try:
-                parsed = json.loads(cleaned_content)
-                caption_text = parsed.get("analysis", content)
-                metadata = parsed.get("metadata", {})
-                print(f"🔍 Gemini: JSON parsed successfully, metadata keys: {list(metadata.keys())}")
-                
-                if metadata.get("epsg"):
-                    epsg_value = metadata["epsg"]
-                    allowed_epsg = ["4326", "3857", "32617", "32633", "32634", "OTHER"]
-                    if epsg_value not in allowed_epsg:
-                        metadata["epsg"] = "OTHER"
-                        print(f"🔍 Gemini: EPSG value {epsg_value} not in allowed list, set to OTHER")
-            except json.JSONDecodeError as e:
-                print(f"⚠️ Gemini: JSON parse error: {e}")
-                caption_text = content
-                metadata = {}
+        try:
+            parsed = json.loads(cleaned_content)
+            caption_text = parsed.get("analysis", content)
+            metadata = parsed.get("metadata", {})
+            if metadata.get("epsg"):
+                epsg_value = metadata["epsg"]
+                allowed_epsg = ["4326", "3857", "32617", "32633", "32634", "OTHER"]
+                if epsg_value not in allowed_epsg:
+                    metadata["epsg"] = "OTHER"
+        except json.JSONDecodeError:
+            caption_text = content
+            metadata = {}
 
-            raw_response: Dict[str, Any] = {"model": self.model_id}
-            
-            print(f"🔍 Gemini: Final metadata: {metadata}")
-            print(f"🔍 Gemini: Caption generation completed successfully in {elapsed:.2f}s")
+        raw_response: Dict[str, Any] = {"model": self.model_id}
 
-            return {
-                "caption": caption_text,
-                "metadata": metadata,
-                "confidence": None,
-                "processing_time": elapsed,
-                "raw_response": raw_response,
-            }
-            
-        except Exception as e:
-            error_msg = str(e)
-            error_type = type(e).__name__
-            print(f"❌ Gemini: Error occurred during caption generation")
-            print(f"❌ Gemini: Error type: {error_type}")
-            print(f"❌ Gemini: Error message: {error_msg}")
-            
-            # Check for specific error types
-            if "quota" in error_msg.lower() or "limit" in error_msg.lower():
-                print(f"❌ Gemini: Quota or rate limit exceeded detected")
-                raise Exception(f"MODEL_UNAVAILABLE: GEMINI15 is currently unavailable (quota/rate limit exceeded). Switching to another model.")
-            elif "authentication" in error_msg.lower() or "invalid" in error_msg.lower() or "api_key" in error_msg.lower():
-                print(f"❌ Gemini: Authentication or API key error detected")
-                raise Exception(f"MODEL_UNAVAILABLE: GEMINI15 is currently unavailable (authentication error). Switching to another model.")
-            elif "timeout" in error_msg.lower() or "connection" in error_msg.lower():
-                print(f"❌ Gemini: Network timeout or connection error detected")
-                raise Exception(f"MODEL_UNAVAILABLE: GEMINI15 is currently unavailable (network error). Switching to another model.")
-            else:
-                print(f"❌ Gemini: Generic error, converting to MODEL_UNAVAILABLE")
-                raise Exception(f"MODEL_UNAVAILABLE: GEMINI15 is currently unavailable ({error_type}: {error_msg}). Switching to another model.")
+        return {
+            "caption": caption_text,
+            "metadata": metadata,
+            "confidence": None,
+            "processing_time": elapsed,
+            "raw_response": raw_response,
+        }
 
 

py_backend/app/services/gpt4v_service.py

@@ -15,15 +15,9 @@ class GPT4VService(VLMService):
     
     async def generate_caption(self, image_bytes: bytes, prompt: str, metadata_instructions: str = "") -> Dict[str, Any]:
         """Generate caption using GPT-4 Vision"""
-        print(f"🔍 GPT-4V: Starting caption generation for {len(image_bytes)} bytes")
-        print(f"🔍 GPT-4V: Prompt: {prompt[:100]}...")
-        print(f"🔍 GPT-4V: Metadata instructions: {metadata_instructions[:100]}...")
-        
         try:
             image_base64 = base64.b64encode(image_bytes).decode('utf-8')
-            print(f"🔍 GPT-4V: Image encoded to base64, length: {len(image_base64)}")
             
-            print(f"🔍 GPT-4V: Calling OpenAI API with model: gpt-4o")
             response = await asyncio.to_thread(
                 self.client.chat.completions.create,
                 model="gpt-4o",
@@ -44,10 +38,7 @@ class GPT4VService(VLMService):
                 max_tokens=800
             )
             
-            print(f"🔍 GPT-4V: API call successful, response received")
             content = response.choices[0].message.content
-            print(f"🔍 GPT-4V: Raw content length: {len(content)}")
-            print(f"🔍 GPT-4V: Content preview: {content[:200]}...")
             
             cleaned_content = content.strip()
             if cleaned_content.startswith("```json"):
@@ -59,9 +50,7 @@ class GPT4VService(VLMService):
             metadata = {}
             try:
                 metadata = json.loads(cleaned_content)
-                print(f"🔍 GPT-4V: JSON parsed successfully, metadata keys: {list(metadata.keys())}")
-            except json.JSONDecodeError as e:
-                print(f"⚠️ GPT-4V: JSON parse error: {e}")
+            except json.JSONDecodeError:
                 if "```json" in content:
                     json_start = content.find("```json") + 7
                     json_end = content.find("```", json_start)
@@ -69,21 +58,16 @@ class GPT4VService(VLMService):
                         json_str = content[json_start:json_end].strip()
                         try:
                             metadata = json.loads(json_str)
-                            print(f"🔍 GPT-4V: Extracted JSON from code blocks successfully")
-                        except json.JSONDecodeError as e2:
-                            print(f"⚠️ GPT-4V: Code block JSON parse also failed: {e2}")
+                        except json.JSONDecodeError as e:
+                            print(f"JSON parse error: {e}")
                 else:
                     import re
                     json_match = re.search(r'\{[^{}]*"metadata"[^{}]*\{[^{}]*\}', content)
                     if json_match:
                         try:
                             metadata = json.loads(json_match.group())
-                            print(f"🔍 GPT-4V: Extracted JSON using regex successfully")
-                        except json.JSONDecodeError as e3:
-                            print(f"⚠️ GPT-4V: Regex JSON extraction failed: {e3}")
-            
-            print(f"🔍 GPT-4V: Final metadata: {metadata}")
-            print(f"🔍 GPT-4V: Caption generation completed successfully")
+                        except json.JSONDecodeError:
+                            pass
             
             return {
                 "caption": cleaned_content,
@@ -96,22 +80,4 @@ class GPT4VService(VLMService):
             }
             
         except Exception as e:
-            error_msg = str(e)
-            error_type = type(e).__name__
-            print(f"❌ GPT-4V: Error occurred during caption generation")
-            print(f"❌ GPT-4V: Error type: {error_type}")
-            print(f"❌ GPT-4V: Error message: {error_msg}")
-            
-            # Check for specific error types
-            if "rate_limit" in error_msg.lower() or "quota" in error_msg.lower():
-                print(f"❌ GPT-4V: Rate limit or quota exceeded detected")
-                raise Exception(f"MODEL_UNAVAILABLE: GPT-4O is currently unavailable (rate limit/quota exceeded). Switching to another model.")
-            elif "authentication" in error_msg.lower() or "invalid" in error_msg.lower() or "api_key" in error_msg.lower():
-                print(f"❌ GPT-4V: Authentication or API key error detected")
-                raise Exception(f"MODEL_UNAVAILABLE: GPT-4O is currently unavailable (authentication error). Switching to another model.")
-            elif "timeout" in error_msg.lower() or "connection" in error_msg.lower():
-                print(f"❌ GPT-4V: Network timeout or connection error detected")
-                raise Exception(f"MODEL_UNAVAILABLE: GPT-4O is currently unavailable (network error). Switching to another model.")
-            else:
-                print(f"❌ GPT-4V: Generic error, converting to MODEL_UNAVAILABLE")
-                raise Exception(f"MODEL_UNAVAILABLE: GPT-4O is currently unavailable ({error_type}: {error_msg}). Switching to another model.") 
+            raise Exception(f"GPT-4 Vision API error: {str(e)}") 

py_backend/app/services/vlm_service.py

@@ -63,37 +63,64 @@ class VLMServiceManager:
         return list(self.services.keys())
     
     async def generate_caption(self, image_bytes: bytes, prompt: str, metadata_instructions: str = "", model_name: str | None = None, db_session = None) -> dict:
-        """Generate caption using available VLM services with fallback"""
+        """Generate caption using the specified model or fallback to available service."""
         
-        # Select initial service
         service = None
-        if model_name:
+        if model_name and model_name != "random":
             service = self.services.get(model_name)
+            if not service:
+                print(f"Model '{model_name}' not found, using fallback")
         
-        if not service:
+        if not service and self.services:
+            # If random is selected or no specific model, choose a random available service
             if db_session:
+                # Check database availability for random selection
                 try:
                     from .. import crud
                     available_models = crud.get_models(db_session)
                     available_model_codes = [m.m_code for m in available_models if m.is_available]
                     
+                    print(f"DEBUG: Available models in database: {available_model_codes}")
+                    print(f"DEBUG: Registered services: {list(self.services.keys())}")
+                    
+                    # Filter services to only those marked as available in database
                     available_services = [s for s in self.services.values() if s.model_name in available_model_codes]
+                    
+                    print(f"DEBUG: Available services after filtering: {[s.model_name for s in available_services]}")
+                    
                     if available_services:
                         import random
+                        import time
+                        # Use current time as seed for better randomness
+                        random.seed(int(time.time() * 1000000) % 1000000)
+                        
+                        # Shuffle the list first for better randomization
                         shuffled_services = available_services.copy()
                         random.shuffle(shuffled_services)
+                        
                         service = shuffled_services[0]
+                        print(f"Randomly selected service: {service.model_name} (from {len(available_services)} available)")
+                        print(f"DEBUG: All available services were: {[s.model_name for s in available_services]}")
+                        print(f"DEBUG: Shuffled order: {[s.model_name for s in shuffled_services]}")
                     else:
+                        # Fallback to any service
                         service = next(iter(self.services.values()))
+                        print(f"Using fallback service: {service.model_name}")
                 except Exception as e:
+                    print(f"Error checking database availability: {e}, using fallback")
                     service = next(iter(self.services.values()))
+                    print(f"Using fallback service: {service.model_name}")
             else:
+                # No database session, use service property
                 available_services = [s for s in self.services.values() if s.is_available]
                 if available_services:
                     import random
                     service = random.choice(available_services)
+                    print(f"Randomly selected service: {service.model_name}")
                 else:
+                    # Fallback to any service
                     service = next(iter(self.services.values()))
+                    print(f"Using fallback service: {service.model_name}")
         
         if not service:
             raise ValueError("No VLM services available")
@@ -114,10 +141,12 @@ class VLMServiceManager:
                 return result
             except Exception as e:
                 error_str = str(e)
+                print(f"Error with service {service.model_name}: {error_str}")
                 
                 # Check if it's a model unavailable error (any type of error)
                 if "MODEL_UNAVAILABLE" in error_str:
                     attempted_services.add(service.model_name)
+                    print(f"Model {service.model_name} is unavailable, trying another service...")
                     
                     # Try to find another available service
                     if db_session:
@@ -131,24 +160,29 @@ class VLMServiceManager:
                                 if (next_service.model_name in available_model_codes and 
                                     next_service.model_name not in attempted_services):
                                     service = next_service
+                                    print(f"Switching to fallback service: {service.model_name}")
                                     break
                             else:
                                 # No more available services, use any untried service
                                 for next_service in self.services.values():
                                     if next_service.model_name not in attempted_services:
                                         service = next_service
+                                        print(f"Using untried service as fallback: {service.model_name}")
                                         break
                         except Exception as db_error:
+                            print(f"Error checking database availability: {db_error}")
                             # Fallback to any untried service
                             for next_service in self.services.values():
                                 if next_service.model_name not in attempted_services:
                                     service = next_service
+                                    print(f"Using untried service as fallback: {service.model_name}")
                                     break
                     else:
                         # No database session, use any untried service
                         for next_service in self.services.values():
                             if next_service.model_name not in attempted_services:
                                 service = next_service
+                                print(f"Using untried service as fallback: {service.model_name}")
                                 break
                     
                     if not service:
@@ -157,6 +191,7 @@ class VLMServiceManager:
                     continue  # Try again with new service
                 else:
                     # Non-model-unavailable error, don't retry
+                    print(f"Non-model-unavailable error, not retrying: {error_str}")
                     raise
         
         # If we get here, we've tried all services