Add fallback logic and logger fix

Dockerfile

@@ -14,9 +14,11 @@ COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 # Copy App and Model
 COPY app.py .
+COPY api.py .
 COPY best.pt .
+
 # Expose the default HF Space port
 ENV PORT=7860
 EXPOSE 7860
 # Run the FastAPI app with Uvicorn
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "api:app", "--host", "0.0.0.0", "--port", "7860"]

api.py

@@ -0,0 +1,164 @@
+import io
+import json
+import logging
+import os
+from typing import Optional
+
+import cv2
+import numpy as np
+import uvicorn
+from fastapi import FastAPI, File, Form, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from PIL import Image
+from ultralytics import YOLO
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="Arise AI API", version="1.0.0")
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Load Model
+try:
+    model = YOLO("best.pt")
+    logger.info("YOLO model loaded successfully.")
+except Exception as e:
+    logger.error(f"Failed to load model: {e}")
+    model = None
+
+@app.get("/")
+def read_root():
+    return {"status": "Active", "service": "Arise AI Backend"}
+
+@app.post("/analyze")
+async def analyze_endpoint(
+    image: UploadFile = File(...),
+    description: str = Form(""),
+    latitude: str = Form("0"),
+    longitude: str = Form("0"),
+    timestamp: str = Form(""),
+    user_email: str = Form(None)
+):
+    if not model:
+        raise HTTPException(status_code=503, detail="AI Model not initialized")
+
+    try:
+        # Read Image
+        contents = await image.read()
+        pil_image = Image.open(io.BytesIO(contents)).convert("RGB")
+        img_np = np.array(pil_image)
+
+        # Run Inference
+        logger.info("Running YOLO inference...")
+        results = model(img_np, conf=0.25)  # Lower confidence a bit to catch more
+        
+        detections = []
+        primary_issue = "Unknown"
+        max_conf = 0.0
+        
+        result = results[0]
+        
+        # Analyze Detections
+        if len(result.boxes) > 0:
+            for box in result.boxes:
+                cls_id = int(box.cls)
+                conf = float(box.conf)
+                label = model.names[cls_id]
+                
+                detections.append({
+                    "class": label,
+                    "confidence": conf
+                })
+                
+                if conf > max_conf:
+                    max_conf = conf
+                    primary_issue = label
+
+        # Fallback: Check Description if YOLO fails
+        if primary_issue == "Unknown" and description:
+            logger.info(f"YOLO failed, checking description: {description}")
+            desc_lower = description.lower()
+            keywords = {
+                "pothole": "Pothole",
+                "garbage": "Garbage",
+                "trash": "Garbage",
+                "street light": "Streetlight",
+                "streetlight": "Streetlight",
+                "accident": "Accident",
+                "water": "Drainagen", # Typo in map, should match category_map keys if possible or be standard
+                "drainage": "Drainagen"
+            }
+            
+            for key, val in keywords.items():
+                if key in desc_lower:
+                    primary_issue = val
+                    max_conf = 0.5 # Moderate confidence for text match
+                    ai_summary = f"Issue identified based on description: {val}"
+                    break
+
+
+        # Process Image for Overlay (if needed)
+        # We can return the base64 of the plotted image
+        annotated_frame = result.plot()
+        is_success, buffer = cv2.imencode(".jpg", cv2.cvtColor(annotated_frame, cv2.COLOR_RGB2BGR))
+        processed_image_base64 = None
+        if is_success:
+            import base64
+            processed_image_base64 = base64.b64encode(buffer).decode("utf-8")
+
+        # Map to Civicsense categories
+        category_map = {
+            "pothole": "Public Works",
+            "garbage": "Sanitation",
+            "streetlight": "Electricity",
+            "accident": "Emergency",
+            "drainagen": "Water & Sewerage"
+            # Add more mappings as per trained model classes
+        }
+        
+        department = category_map.get(primary_issue.lower(), "General")
+        
+        # Determine Severity
+        severity = "Medium"
+        if primary_issue.lower() in ["accident", "pothole"]:
+            severity = "High" if max_conf > 0.7 else "Medium"
+        elif primary_issue.lower() == "garbage":
+            severity = "Low" if max_conf < 0.5 else "Medium"
+
+        # Generate specific summary
+        ai_summary = f"Detected {primary_issue} with {max_conf:.2f} confidence." if primary_issue != "Unknown" else "No specific civic issues detected."
+
+        response_data = {
+            "status": "Success",
+            "issue_type": primary_issue,
+            "civic_confidence": max_conf,
+            "severity": severity,
+            "department": department,
+            "ai_summary": ai_summary,
+            "detections": detections,
+            "processed_image": processed_image_base64,
+            "resolution_estimation": {
+                "estimated_hours": 24 if severity == "High" else 48
+            }
+        }
+        
+        logger.info(f"Analysis complete: {primary_issue}")
+        return response_data
+
+    except Exception as e:
+        logger.error(f"Analysis Failed: {e}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

git-lfs.tar.gz

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

requirements.txt

@@ -8,4 +8,3 @@ geopy
 fastapi
 uvicorn
 python-multipart
-gradio