feat: implement daily civic intelligence refinement engine

backend/ai_factory.py

@@ -7,13 +7,13 @@
 import os
 from typing import Literal
 
-from backend.ai_interfaces import ActionPlanService, ChatService, MLASummaryService
-from backend.gemini_services import (
+from ai_interfaces import ActionPlanService, ChatService, MLASummaryService
+from gemini_services import (
     create_gemini_action_plan_service,
     create_gemini_chat_service,
     create_gemini_mla_summary_service,
 )
-from backend.mock_services import (
+from mock_services import (
     create_mock_action_plan_service,
     create_mock_chat_service,
     create_mock_mla_summary_service,

backend/ai_service.py

@@ -9,8 +9,8 @@
 
 import httpx
 
-from backend.retry_utils import exponential_backoff_retry
-from backend.exceptions import AIServiceException
+from retry_utils import exponential_backoff_retry
+from exceptions import AIServiceException
 
 # Configure logging
 logger = logging.getLogger(__name__)

backend/bot.py

@@ -4,9 +4,9 @@
 import threading
 from telegram import Update, ReplyKeyboardMarkup, ReplyKeyboardRemove
 from telegram.ext import ApplicationBuilder, ContextTypes, CommandHandler, MessageHandler, filters, ConversationHandler
-from backend.database import engine, SessionLocal
+from database import engine, SessionLocal
 
-from backend.models import Base, Issue
+from models import Base, Issue
 
 
 # Enable logging

backend/escalation_engine.py

@@ -7,10 +7,10 @@
 from typing import List, Dict, Any, Optional
 from sqlalchemy.orm import Session
 from sqlalchemy import and_, or_
-from backend.models import Grievance, Jurisdiction, EscalationAudit, GrievanceStatus, JurisdictionLevel, EscalationReason, SeverityLevel
-from backend.database import SessionLocal
-from backend.routing_service import RoutingService
-from backend.sla_config_service import SLAConfigService
+from models import Grievance, Jurisdiction, EscalationAudit, GrievanceStatus, JurisdictionLevel, EscalationReason, SeverityLevel
+from database import SessionLocal
+from routing_service import RoutingService
+from sla_config_service import SLAConfigService
 
 class EscalationEngine:
     """

backend/exceptions.py

@@ -12,7 +12,7 @@
 from sqlalchemy.exc import SQLAlchemyError, IntegrityError
 import httpx
 
-from backend.schemas import ErrorResponse
+from schemas import ErrorResponse
 
 logger = logging.getLogger(__name__)
 

backend/flood_detection.py

@@ -1,6 +1,10 @@
-from hf_service import client
 from PIL import Image
 import io
+import httpx
+from hf_service import query_hf_api
+import asyncio
+
+_hf_client = httpx.AsyncClient()
 
 def detect_flooding(image: Image.Image):
     """
@@ -15,12 +19,23 @@ def detect_flooding(image: Image.Image):
         image.save(img_byte_arr, format=image.format if image.format else 'JPEG')
         img_byte_arr = img_byte_arr.getvalue()
 
-        # Using the same model as vandalism for consistency and caching benefits
-        results = client.zero_shot_image_classification(
-            image=img_byte_arr,
-            labels=labels,
-            model="openai/clip-vit-base-patch32"
-        )
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+
+        if loop and loop.is_running():
+            # If we're already in an async context, this synchronous function won't work easily with our async HF client wrapper.
+            # But we can try to fall back or spawn a thread if really needed. For now, try running synchronously using asyncio.run if possible.
+            import threading
+            def _run():
+                return asyncio.run(query_hf_api(img_byte_arr, labels, _hf_client))
+            # Just do a blocking call inside a thread
+            import concurrent.futures
+            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+                results = pool.submit(_run).result()
+        else:
+            results = asyncio.run(query_hf_api(img_byte_arr, labels, _hf_client))
 
         # Filter for flooding related
         flood_labels = ["flooded street", "waterlogging", "submerged car"]

backend/flooding_detection.py

@@ -1,5 +1,5 @@
 from PIL import Image
-from backend.local_ml_service import detect_flooding_local
+from local_ml_service import detect_flooding_local
 
 async def detect_flooding(image: Image.Image):
     """

backend/gemini_services.py

@@ -3,13 +3,13 @@
 """
 from typing import Dict, Optional
 import asyncio
-from backend.ai_interfaces import ActionPlanService, ChatService, MLASummaryService
-from backend.ai_service import (
+from ai_interfaces import ActionPlanService, ChatService, MLASummaryService
+from ai_service import (
     generate_action_plan as _generate_action_plan,
     chat_with_civic_assistant as _chat_with_civic_assistant
 )
-from backend.gemini_summary import generate_mla_summary as _generate_mla_summary
-from backend.exceptions import AIServiceException
+from gemini_summary import generate_mla_summary as _generate_mla_summary
+from exceptions import AIServiceException
 
 
 class GeminiActionPlanService(ActionPlanService):

backend/gemini_summary.py

@@ -11,7 +11,7 @@
 
 import httpx
 
-from backend.retry_utils import exponential_backoff_retry
+from retry_utils import exponential_backoff_retry
 
 # Configure logging
 logger = logging.getLogger(__name__)

backend/grievance_service.py

@@ -9,11 +9,11 @@
 from sqlalchemy.orm import Session, joinedload
 from datetime import datetime, timezone, timedelta
 
-from backend.models import Grievance, Jurisdiction, GrievanceStatus, SeverityLevel
-from backend.database import SessionLocal
-from backend.routing_service import RoutingService
-from backend.sla_config_service import SLAConfigService
-from backend.escalation_engine import EscalationEngine
+from models import Grievance, Jurisdiction, GrievanceStatus, SeverityLevel
+from database import SessionLocal
+from routing_service import RoutingService
+from sla_config_service import SLAConfigService
+from escalation_engine import EscalationEngine
 
 class GrievanceService:
     """

backend/hf_service.py

@@ -88,6 +88,14 @@ async def _make_request(client, image_bytes, labels):
             raise ExternalAPIException("Hugging Face API", str(e)) from e
 
 def _prepare_image_bytes(image: Union[Image.Image, bytes]) -> bytes:
+    if isinstance(image, bytes):
+        return image
+    import io
+    img_byte_arr = io.BytesIO()
+    image.save(img_byte_arr, format='JPEG')
+    return img_byte_arr.getvalue()
+
+async def detect_vandalism_clip(image: Union[Image.Image, bytes], client: httpx.AsyncClient) -> List[Dict[str, Any]]:
     """
     Detects vandalism/graffiti using Zero-Shot Image Classification with CLIP (Async).
     Includes retry logic with exponential backoff for transient failures.

backend/infrastructure_detection.py

@@ -1,4 +1,4 @@
-from backend.local_ml_service import detect_infrastructure_local
+from local_ml_service import detect_infrastructure_local
 from PIL import Image
 
 async def detect_infrastructure(image: Image.Image):

backend/init_db.py

@@ -1,5 +1,5 @@
 from sqlalchemy import text
-from backend.database import engine
+from database import engine
 import logging
 
 logger = logging.getLogger(__name__)

backend/init_grievance_system.py

@@ -3,17 +3,17 @@
 Sets up sample jurisdictions, SLA configurations, and test data.
 """
 
-from backend.database import SessionLocal, engine
-from backend.models import Jurisdiction, JurisdictionLevel, SLAConfig, SeverityLevel
-from backend.grievance_service import GrievanceService
+from database import SessionLocal, engine
+from models import Jurisdiction, JurisdictionLevel, SLAConfig, SeverityLevel
+from grievance_service import GrievanceService
 import json
 
 def initialize_grievance_system():
     """
     Initialize the grievance system with sample data.
     """
     # Create tables
-    from backend.models import Base
+    from models import Base
     Base.metadata.create_all(bind=engine)
 
     db = SessionLocal()

backend/local_ml_service.py

@@ -10,7 +10,7 @@
 import threading
 from fastapi.concurrency import run_in_threadpool
 
-from backend.exceptions import DetectionException
+from exceptions import DetectionException
 
 # Configure logging
 logger = logging.getLogger(__name__)

backend/main.py

@@ -1,3 +1,4 @@
+import sys
 from fastapi import FastAPI, UploadFile, File, Form, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.concurrency import run_in_threadpool
@@ -11,8 +12,10 @@
 import json
 import os
 import io
+from functools import lru_cache
 
 # Add the project root to sys.path so we can import 'backend' modules
+import sys
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from fastapi import FastAPI, HTTPException, UploadFile, File, Form, BackgroundTasks, Depends, Query
@@ -21,7 +24,9 @@
 from fastapi.concurrency import run_in_threadpool
 from pydantic import BaseModel
 from sqlalchemy.orm import Session
+from schemas import StatsResponse, MLStatusResponse
 from database import SessionLocal, engine, Base
+from ai_factory import create_all_ai_services
 from models import Issue
 from contextlib import asynccontextmanager
 import shutil
@@ -65,9 +70,9 @@ async def lifespan(app: FastAPI):
     try:
         load_maharashtra_pincode_data()
         load_maharashtra_mla_data()
-        logger.info("Maharashtra data pre-loaded successfully.")
+        print("Maharashtra data pre-loaded successfully.")
     except Exception as e:
-        logger.error(f"Error pre-loading Maharashtra data: {e}")
+        print(f"Error pre-loading Maharashtra data: {e}")
 
     # Run database migrations
     try:
@@ -133,27 +138,18 @@ def read_root():
         "version": "1.0.0"
     }
 
-@app.get("/", response_model=SuccessResponse)
-def root():
-    return SuccessResponse(
-        message="VishwaGuru API is running",
-        data={
-            "service": "VishwaGuru API",
-            "version": "1.0.0"
-        }
-    )
-
-@app.get("/health", response_model=HealthResponse)
+@app.get("/health")
 def health():
-    return HealthResponse(
-        status="healthy",
-        timestamp=datetime.now(timezone.utc),
-        version="1.0.0",
-        services={
+    from datetime import datetime, timezone
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "version": "1.0.0",
+        "services": {
             "database": "connected",
             "ai_services": "initialized"
         }
-    )
+    }
 
 @app.get("/api/stats", response_model=StatsResponse)
 def get_stats(db: Session = Depends(get_db)):
@@ -234,45 +230,39 @@ async def create_issue(
 
         # Offload blocking file I/O to a thread
         def save_file():
-            with open(image_path, "wb") as buffer:
+            with open(file_location, "wb") as buffer:
                 shutil.copyfileobj(image.file, buffer)
 
         await asyncio.to_thread(save_file)
 
-    # Offload blocking DB operations to a thread
-    def save_to_db():
-        new_issue = Issue(
-            description=description,
-            category=category,
-            image_path=image_path,
-            source="web"
-        )
-        db.add(new_issue)
-        db.commit()
-        db.refresh(new_issue)
-        return new_issue
-
-    new_issue = await asyncio.to_thread(save_to_db)
-
         # Generate Action Plan (AI)
         action_plan = await generate_action_plan(description, category, file_location)
 
-        db_issue = Issue(
-            description=description,
-            category=category,
-            image_path=file_location,
-            source=source,
-            user_email=user_email
-        )
-        db.add(db_issue)
-        db.commit()
-        db.refresh(db_issue)
+        # Offload blocking DB operations to a thread
+        def save_to_db():
+            new_issue = Issue(
+                description=description,
+                category=category,
+                image_path=file_location,
+                source=source,
+                user_email=user_email
+            )
+            db.add(new_issue)
+            db.commit()
+            db.refresh(new_issue)
+            return new_issue
 
-    return {
-        "id": new_issue.id,
-        "message": "Issue reported successfully",
-        "action_plan": action_plan
-    }
+        new_issue = await asyncio.to_thread(save_to_db)
+
+        return {
+            "id": new_issue.id,
+            "message": "Issue reported successfully",
+            "action_plan": action_plan
+        }
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=str(e))
 
 @lru_cache(maxsize=1)
 def _load_responsibility_map():