Fix Pydantic field conflicts and model loading issues; add test and upload scripts for HF deployment

app/models/inference.py

@@ -25,6 +25,8 @@ class Detection(BaseModel):
 
 class ModelInfo(BaseModel):
     """Model information."""
+    model_config = {"protected_namespaces": ()}
+
     model_name: str = Field(..., description="Name of the model")
     total_classes: int = Field(..., description="Total number of species classes")
     device: str = Field(..., description="Device used for inference")
@@ -102,6 +104,8 @@ class SpeciesListResponse(BaseModel):
 
 class HealthResponse(BaseModel):
     """Response model for health check."""
+    model_config = {"protected_namespaces": ()}
+
     status: str = Field(..., description="API status")
     model_loaded: bool = Field(..., description="Whether the model is loaded")
     model_info: Optional[ModelInfo] = Field(default=None, description="Model information")
@@ -117,6 +121,8 @@ class ErrorResponse(BaseModel):
 
 class APIInfo(BaseModel):
     """API information response."""
+    model_config = {"protected_namespaces": ()}
+
     name: str = Field(..., description="API name")
     version: str = Field(..., description="API version")
     description: str = Field(..., description="API description")

app/services/model_service.py

@@ -27,14 +27,26 @@ class ModelService:
         Downloads from HuggingFace Hub if not present locally.
         """
         model_path = Path(settings.MODEL_PATH)
-        
+
         # Check if model exists locally
         if not model_path.exists():
             logger.info(f"Model not found at {model_path}, downloading from HuggingFace Hub...")
-            await self._download_model()
-        
+            try:
+                await self._download_model()
+            except Exception as e:
+                logger.error(f"Failed to download model: {e}")
+                # Continue anyway - the API can still run without the model
+
         # Load class names if available
         await self._load_class_names()
+
+        # Try to initialize the model to catch loading errors early
+        try:
+            self.get_model()
+            logger.info("Model loaded successfully during startup")
+        except Exception as e:
+            logger.error(f"Model failed to load during startup: {e}")
+            # Don't fail startup - let health checks handle this
     
     async def _download_model(self) -> None:
         """Download model from HuggingFace Hub."""
@@ -122,20 +134,38 @@ class ModelService:
     def get_model_info(self) -> Dict:
         """
         Get comprehensive model information.
-        
+
         Returns:
             Dictionary with model information
         """
-        model = self.get_model()
-        class_names = self.get_class_names()
-        
-        return {
-            "model_name": settings.MODEL_NAME,
-            "total_classes": len(class_names) if class_names else 0,
-            "device": model.device,
-            "model_path": settings.MODEL_PATH,
-            "huggingface_repo": settings.HUGGINGFACE_REPO
-        }
+        try:
+            model = self.get_model()
+            class_names = self.get_class_names()
+
+            # Safely get device info
+            device_info = "unknown"
+            try:
+                device_info = str(model.device) if hasattr(model, 'device') else "unknown"
+            except Exception as e:
+                logger.warning(f"Could not get device info: {e}")
+
+            return {
+                "model_name": settings.MODEL_NAME,
+                "total_classes": len(class_names) if class_names else 0,
+                "device": device_info,
+                "model_path": settings.MODEL_PATH,
+                "huggingface_repo": settings.HUGGINGFACE_REPO
+            }
+        except Exception as e:
+            logger.error(f"Failed to get model info: {str(e)}")
+            # Return basic info even if model fails
+            return {
+                "model_name": settings.MODEL_NAME,
+                "total_classes": 0,
+                "device": "unknown",
+                "model_path": settings.MODEL_PATH,
+                "huggingface_repo": settings.HUGGINGFACE_REPO
+            }
     
     async def health_check(self) -> Dict:
         """

test_with_images.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""
+Test the Marine Species Identification API with real marine species images.
+"""
+
+import requests
+import base64
+import json
+import time
+from pathlib import Path
+import sys
+
+
+def encode_image_to_base64(image_path: str) -> str:
+    """Encode an image file to base64 string."""
+    try:
+        with open(image_path, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode('utf-8')
+    except Exception as e:
+        print(f"Error encoding image {image_path}: {e}")
+        return None
+
+
+def test_api_with_image(api_url: str, image_path: str, image_name: str):
+    """Test the API with a specific image."""
+    print(f"\n🐟 Testing with {image_name}")
+    print("-" * 50)
+    
+    # Encode image
+    print("📷 Encoding image...")
+    image_b64 = encode_image_to_base64(image_path)
+    if not image_b64:
+        print("❌ Failed to encode image")
+        return False
+    
+    # Prepare request
+    detection_request = {
+        "image": image_b64,
+        "confidence_threshold": 0.25,
+        "iou_threshold": 0.45,
+        "image_size": 640,
+        "return_annotated_image": True
+    }
+    
+    try:
+        print("🔍 Sending detection request...")
+        start_time = time.time()
+        
+        response = requests.post(
+            f"{api_url}/api/v1/detect",
+            json=detection_request,
+            timeout=60
+        )
+        
+        request_time = time.time() - start_time
+        print(f"⏱️  Request completed in {request_time:.2f}s")
+        print(f"📊 Status Code: {response.status_code}")
+        
+        if response.status_code == 200:
+            result = response.json()
+            
+            detections = result.get('detections', [])
+            processing_time = result.get('processing_time', 0)
+            image_dims = result.get('image_dimensions', {})
+            
+            print(f"✅ SUCCESS!")
+            print(f"   Processing Time: {processing_time:.3f}s")
+            print(f"   Image Dimensions: {image_dims.get('width')}x{image_dims.get('height')}")
+            print(f"   Detections Found: {len(detections)}")
+            
+            if detections:
+                print(f"   🎯 Top Detections:")
+                for i, detection in enumerate(detections[:5]):  # Show top 5
+                    species = detection.get('class_name', 'Unknown')
+                    confidence = detection.get('confidence', 0)
+                    bbox = detection.get('bbox', {})
+                    print(f"      {i+1}. {species} (confidence: {confidence:.3f})")
+                    print(f"         Box: x={bbox.get('x', 0):.0f}, y={bbox.get('y', 0):.0f}, "
+                          f"w={bbox.get('width', 0):.0f}, h={bbox.get('height', 0):.0f}")
+            else:
+                print("   ℹ️  No marine species detected")
+            
+            # Check annotated image
+            if result.get('annotated_image'):
+                print("   🖼️  Annotated image returned")
+            
+            return True
+            
+        elif response.status_code == 503:
+            print("❌ Service Unavailable - Model may not be loaded")
+            print(f"   Response: {response.text}")
+            return False
+            
+        else:
+            print(f"❌ Request failed with status {response.status_code}")
+            try:
+                error_detail = response.json()
+                print(f"   Error: {error_detail}")
+            except:
+                print(f"   Response: {response.text}")
+            return False
+            
+    except requests.exceptions.Timeout:
+        print("❌ Request timed out")
+        return False
+    except Exception as e:
+        print(f"❌ Request failed: {e}")
+        return False
+
+
+def main():
+    """Main test function."""
+    # API URL - can be overridden with command line argument
+    api_url = sys.argv[1] if len(sys.argv) > 1 else "https://seamo-ai-fishapi.hf.space"
+    
+    print("🐟 Marine Species Identification API - Image Testing")
+    print("=" * 60)
+    print(f"API URL: {api_url}")
+    
+    # Check API health first
+    print("\n🏥 Checking API health...")
+    try:
+        health_response = requests.get(f"{api_url}/api/v1/health", timeout=10)
+        if health_response.status_code == 200:
+            health_data = health_response.json()
+            print(f"   Status: {health_data.get('status')}")
+            print(f"   Model Loaded: {health_data.get('model_loaded')}")
+        else:
+            print(f"   Health check failed: {health_response.status_code}")
+    except Exception as e:
+        print(f"   Health check error: {e}")
+    
+    # Find test images
+    image_dir = Path("docs/gradio/images")
+    if not image_dir.exists():
+        print(f"\n❌ Image directory not found: {image_dir}")
+        print("Please make sure you're running this from the project root directory.")
+        return
+    
+    # Get all image files
+    image_files = []
+    for ext in ['*.png', '*.jpg', '*.jpeg']:
+        image_files.extend(image_dir.glob(ext))
+    
+    if not image_files:
+        print(f"\n❌ No image files found in {image_dir}")
+        return
+    
+    print(f"\n📁 Found {len(image_files)} test images")
+    
+    # Test each image
+    successful_tests = 0
+    total_tests = len(image_files)
+    
+    for image_path in sorted(image_files):
+        success = test_api_with_image(api_url, str(image_path), image_path.name)
+        if success:
+            successful_tests += 1
+        
+        # Small delay between requests
+        time.sleep(1)
+    
+    # Summary
+    print("\n" + "=" * 60)
+    print(f"🎯 Test Summary:")
+    print(f"   Total Tests: {total_tests}")
+    print(f"   Successful: {successful_tests}")
+    print(f"   Failed: {total_tests - successful_tests}")
+    print(f"   Success Rate: {(successful_tests/total_tests)*100:.1f}%")
+    
+    if successful_tests == total_tests:
+        print("🎉 All tests passed!")
+    elif successful_tests > 0:
+        print("⚠️  Some tests passed, some failed")
+    else:
+        print("❌ All tests failed")
+
+
+if __name__ == "__main__":
+    main()

upload_model_to_hf.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""
+Script to upload the marine species model files to HuggingFace Hub.
+This script helps you upload your model files to make them available for the API.
+"""
+
+import os
+import sys
+from pathlib import Path
+from huggingface_hub import HfApi, create_repo
+import argparse
+
+
+def upload_model_files(repo_id: str, local_model_dir: str, token: str = None):
+    """
+    Upload model files to HuggingFace Hub.
+    
+    Args:
+        repo_id: HuggingFace repository ID (e.g., "username/repo-name")
+        local_model_dir: Local directory containing model files
+        token: HuggingFace token (optional, will use saved token if not provided)
+    """
+    
+    print(f"🚀 Uploading model files to HuggingFace Hub")
+    print(f"Repository: {repo_id}")
+    print(f"Local directory: {local_model_dir}")
+    print("=" * 60)
+    
+    # Initialize HF API
+    api = HfApi(token=token)
+    
+    # Check if local directory exists
+    local_path = Path(local_model_dir)
+    if not local_path.exists():
+        print(f"❌ Local directory not found: {local_path}")
+        return False
+    
+    # Find model files
+    model_files = []
+    for pattern in ["*.pt", "*.pth", "*.names", "*.txt"]:
+        model_files.extend(local_path.glob(pattern))
+    
+    if not model_files:
+        print(f"❌ No model files found in {local_path}")
+        print("Looking for: *.pt, *.pth, *.names, *.txt files")
+        return False
+    
+    print(f"📁 Found {len(model_files)} files to upload:")
+    for file in model_files:
+        size_mb = file.stat().st_size / (1024 * 1024)
+        print(f"   - {file.name} ({size_mb:.1f} MB)")
+    
+    try:
+        # Create repository if it doesn't exist
+        print(f"\n🏗️  Creating/checking repository...")
+        try:
+            create_repo(repo_id, exist_ok=True, token=token)
+            print(f"✅ Repository ready: {repo_id}")
+        except Exception as e:
+            print(f"⚠️  Repository creation warning: {e}")
+        
+        # Upload each file
+        print(f"\n📤 Uploading files...")
+        for file_path in model_files:
+            print(f"   Uploading {file_path.name}...")
+            
+            api.upload_file(
+                path_or_fileobj=str(file_path),
+                path_in_repo=file_path.name,
+                repo_id=repo_id,
+                token=token
+            )
+            print(f"   ✅ {file_path.name} uploaded successfully")
+        
+        print(f"\n🎉 All files uploaded successfully!")
+        print(f"🔗 Repository URL: https://huggingface.co/{repo_id}")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Upload failed: {e}")
+        return False
+
+
+def main():
+    """Main function."""
+    parser = argparse.ArgumentParser(description="Upload marine species model to HuggingFace Hub")
+    parser.add_argument("--repo-id", required=True, help="HuggingFace repository ID (e.g., username/repo-name)")
+    parser.add_argument("--model-dir", default="docs/gradio", help="Local directory containing model files")
+    parser.add_argument("--token", help="HuggingFace token (optional)")
+    
+    args = parser.parse_args()
+    
+    print("🐟 Marine Species Model Upload Tool")
+    print("=" * 50)
+    
+    # Check if user is logged in to HuggingFace
+    if not args.token:
+        print("💡 Tip: Make sure you're logged in to HuggingFace CLI:")
+        print("   huggingface-cli login")
+        print()
+    
+    # Upload files
+    success = upload_model_files(
+        repo_id=args.repo_id,
+        local_model_dir=args.model_dir,
+        token=args.token
+    )
+    
+    if success:
+        print(f"\n✅ Upload completed successfully!")
+        print(f"🔧 Next steps:")
+        print(f"   1. Update your API configuration to use: {args.repo_id}")
+        print(f"   2. Redeploy your API")
+        print(f"   3. Test the API with: python test_with_images.py")
+        sys.exit(0)
+    else:
+        print(f"\n❌ Upload failed!")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()