Update api.py

api.py

@@ -72,13 +72,32 @@ def check_spatial_duplicate(lat, lon, issue_type, current_time):
     if lat == 0 or lon == 0:
         return False, "No Location"
     
+    issue_lower = issue_type.lower()
+    
     for report in REPORT_HISTORY:
         # Check Time Window
         if (current_time - report['time']) > timedelta(hours=DEDUP_TIME_WINDOW_HOURS):
             continue
             
-        # Check Issue Type
-        if report['issue'] != issue_type:
+        # Check Issue Type (Loose Match)
+        # If "garbage" in new and "garbage" in old, it's a match.
+        report_issue_lower = report['issue'].lower()
+        
+        # Simple keyword overlap check
+        keywords = ["garbage", "pothole", "accident", "water", "streetlight"]
+        match = False
+        
+        # 1. Exact match (case insensitive)
+        if issue_lower == report_issue_lower:
+            match = True
+        # 2. Keyword match
+        else:
+            for kw in keywords:
+                if kw in issue_lower and kw in report_issue_lower:
+                    match = True
+                    break
+        
+        if not match:
             continue
             
         # Check Distance
@@ -88,6 +107,263 @@ def check_spatial_duplicate(lat, lon, issue_type, current_time):
             
     return False, None
 
+
+def check_velocity_spam(user_email, current_time):
+    """Check if user is submitting too frequently."""
+    if not user_email:
+        return False
+    
+    if user_email not in USER_ACTIVITY:
+        USER_ACTIVITY[user_email] = deque(maxlen=10)
+    
+    timestamps = USER_ACTIVITY[user_email]
+    timestamps.append(current_time)
+    
+    # Filter timestamps within the window
+    recent_activity = [t for t in timestamps if (current_time - t).total_seconds() <= SPAM_VELOCITY_WINDOW_SECONDS]
+    
+    if len(recent_activity) > SPAM_VELOCITY_LIMIT:
+        return True
+    return False
+
+
+@app.get("/")
+def read_root():
+    return {"status": "Active", "service": "Arise AI Backend"}
+
+# --- SYNC HISTORY ENDPOINT ---
+from pydantic import BaseModel
+from typing import List
+
+class HistoryItem(BaseModel):
+    lat: float
+    lon: float
+    issue: str
+    time: float  # Timestamp
+    user: str
+    hash: Optional[str] = None
+
+@app.post("/sync-history")
+async def sync_history(items: List[HistoryItem]):
+    """
+    Syncs recent history from the frontend (Firebase) to the backend.
+    This allows the backend to perform deduplication and spam checks against
+    data that persists across backend restarts.
+    """
+    count = 0
+    for item in items:
+        # Avoid re-adding if already known (simple check by time+user)
+        # In a real overlap scenario we might need a better unique ID, but this is enough for simple seeding.
+        # We only add if timestamp is within the last 24h window roughly.
+        
+        # Add to REPORT_HISTORY
+        # Convert timestamp to datetime
+        dt = datetime.fromtimestamp(item.time / 1000.0) # JS sends ms
+        
+        # Check if already exists (approximate)
+        if any(r['user'] == item.user and abs((r['time'] - dt).total_seconds()) < 1.0 for r in REPORT_HISTORY):
+            continue
+            
+        REPORT_HISTORY.append({
+            'lat': item.lat,
+            'lon': item.lon,
+            'issue': item.issue,
+            'time': dt,
+            'user': item.user,
+            'hash': item.hash or "" # Allow empty hash for legacy without re-analysis
+        })
+        
+        # Add to USER_ACTIVITY for velocity checks
+        if item.user:
+            if item.user not in USER_ACTIVITY:
+                USER_ACTIVITY[item.user] = deque(maxlen=10)
+            USER_ACTIVITY[item.user].append(dt)
+            
+        count += 1
+        
+    logger.info(f"Synced {count} distinct history items from frontend.")
+    return {"status": "success", "synced": count}
+
+@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)
+):
+    try:
+        # Parse inputs
+        try:
+            lat = float(latitude)
+            lon = float(longitude)
+        except ValueError:
+            lat, lon = 0.0, 0.0
+            
+        current_time = datetime.now()
+
+        # Load Image
+        contents = await image.read()
+        pil_image = Image.open(io.BytesIO(contents)).convert("RGB")
+        
+        # Handle EXIF Rotation
+        try:
+            pil_image = ImageOps.exif_transpose(pil_image)
+        except Exception:
+            pass # Keep original if EXIF fails
+
+        img_np = np.array(pil_image)
+        
+        # --- ANALYSIS PHASE ---
+
+        # 1. Spam Detection
+        # A. Blur Check
+        gray = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
+        blur_score = cv2.Laplacian(gray, cv2.CV_64F).var()
+        is_blur_spam = bool(blur_score < 100.0)
+        
+        # B. Velocity Check
+        is_velocity_spam = check_velocity_spam(user_email, current_time)
+        
+        is_spam = is_blur_spam or is_velocity_spam
+        spam_reason = []
+        if is_blur_spam: spam_reason.append(f"Image too blurry (Score: {int(blur_score)})")
+        if is_velocity_spam: spam_reason.append("Submission rate exceeded limit")
+        
+        spam_reason_str = ", ".join(spam_reason) if spam_reason else None
+
+        # Run Inference
+        logger.info("Running YOLO inference...")
+        results = model(img_np, conf=0.1)
+        
+        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 found no objects, checking description: {description}")
+            desc_lower = description.lower()
+            keywords = {
+                "pothole": "Pothole", "pathole": "Pothole", "hole": "Pothole", "road": "Pothole",
+                "garbage": "Garbage", "trash": "Garbage", "waste": "Garbage",
+                "street light": "Streetlight", "streetlight": "Streetlight", "light": "Streetlight",
+                "accident": "Accident", "collision": "Accident",
+                "water": "Drainagen", "drainage": "Drainagen", "leak": "Drainagen"
+            }
+            
+            for key, val in keywords.items():
+                if key in desc_lower:
+                    primary_issue = val
+                    max_conf = 0.5 # Moderate confidence for text match
+                    break
+
+        # 2. Deduplication detection
+        # A. Hash Check (Hamming Distance)
+        current_hash = imagehash.phash(pil_image)
+        phash_str = str(current_hash)
+        
+        # B. Spatial Check
+        is_spatial_dup, spatial_msg = check_spatial_duplicate(lat, lon, primary_issue, current_time)
+        
+        # Check hash against history using Hamming distance < 5
+        is_hash_dup = False
+        for r in REPORT_HISTORY:
+            try:
+                # Convert stored hex string back to hash object
+                stored_hash = imagehash.hex_to_hash(r['hash'])
+                if current_hash - stored_hash < 5:
+                    is_hash_dup = True
+                    break
+            except Exception:
+                continue
+        
+        is_duplicate = is_hash_dup or is_spatial_dup
+        dup_reason = "Duplicate image detected" if is_hash_dup else (spatial_msg if is_spatial_dup else None)
+
+        # Update History
+        REPORT_HISTORY.append({
+            'lat': lat,
+            'lon': lon,
+            'issue': primary_issue,
+            'time': current_time,
+            'user': user_email,
+            'hash': phash_str
+        })
+        
+        # Process Image for Overlay
+        annotated_frame = result.plot(line_width=2, font_size=1.0)
+        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 (Bangalore Specific)
+        category_map = {
+            "pothole": "BBMP - Road Infrastructure",
+            "garbage": "BBMP - Solid Waste Management",
+            "streetlight": "BESCOM - Street Lights",
+            "accident": "Traffic Police / Emergency",
+            "drainagen": "BWSSB - Water & Sewerage",
+            "water": "BWSSB - Water Supply"
+        }
+        
+        department = category_map.get(primary_issue.lower(), "General")
+        
+        # Generate AI Summary (Text Only, No bold markers)
+        summary_lines = []
+        
+        # Line 1: Identification
+        if primary_issue != "Unknown":
+            summary_lines.append(f"Identification: AI detected {primary_issue} with {int(max_conf*100)}% confidence.")
+        else:
+            summary_lines.append("Identification: No specific civic issue could be confidently identified.")
+            
+        # Line 2: Quality Analysis
+        if is_blur_spam:
+            summary_lines.append(f"Image Quality: Poor/Blurry (Score: {int(blur_score)}/100). Please retake.")
+        else:
+            summary_lines.append(f"Image Quality: Good clarity (Score: {int(blur_score)}/100).")
+            
+        # Line 3: Assessment
+        summary_lines.append(f"Assessment: Rated as {severity} severity, routed to {department}.")
+        
+        # Line 4: Status/Warnings
+        status_parts = []
+        if is_duplicate:
+            status_parts.append(f"Duplicate: {dup_reason}.")
+        if is_spam:
+            status_parts.append(f"Spam Flag: {spam_reason_str}.")
+        
+        if not status_parts:
+            status_parts.append("Status: Verified as a unique, valid report.")
+            
+        summary_lines.append(" ".join(status_parts))
+        
+        ai_summary = "\n".join(summary_lines)
+
+        response_data = {
+
 def check_velocity_spam(user_email, current_time):
     """Check if user is submitting too frequently."""
     if not user_email: