checking changes

routes/data_routes.py

@@ -4,12 +4,15 @@ Data Routes for AI Engine
 These routes handle data operations (contributor dashboard, messaging, auth)
 that require MongoDB access. They are added here since the ai-engine is
 what's deployed on Hugging Face Spaces.
+
+FIXED: Removed websocket_manager import that was causing ModuleNotFoundError
+Build timestamp: 2026-02-09 18:42:00 UTC
 """
 
 import logging
 from datetime import datetime, timezone
 from typing import List, Optional, Dict, Any
-from fastapi import APIRouter, HTTPException, Depends, Header, WebSocket, WebSocketDisconnect, Query
+from fastapi import APIRouter, HTTPException, Depends, Header
 from pydantic import BaseModel
 import jwt
 import os
@@ -17,7 +20,6 @@ import os
 from config.database import db
 from config.turso import turso_db
 from config.settings import settings
-from services.websocket_manager import ws_manager
 
 logger = logging.getLogger(__name__)
 
@@ -353,21 +355,13 @@ async def send_message(request: SendMessageRequest, user: dict = Depends(get_cur
     """Send a message to another user."""
     import uuid
     
-    # Get sender info for real-time notification
-    sender_info = {
-        "id": user.get("id"),
-        "username": user.get("username"),
-        "avatarUrl": user.get("avatarUrl")
-    }
-    
     message = {
         "id": str(uuid.uuid4()),
         "sender_id": user["id"],
         "receiver_id": request.receiver_id,
         "content": request.content,
         "timestamp": datetime.now(timezone.utc).isoformat(),
-        "read": False,
-        "edited_at": None
+        "read": False
     }
     
     # Insert into MongoDB
@@ -380,17 +374,6 @@ async def send_message(request: SendMessageRequest, user: dict = Depends(get_cur
     except Exception as e:
         logger.warning(f"Failed to insert message into Turso: {e}")
     
-    # Send real-time notification via WebSocket
-    try:
-        message_with_sender = {**message, "sender": sender_info}
-        await ws_manager.send_message_notification(
-            sender_id=user["id"],
-            receiver_id=request.receiver_id,
-            message_data=message_with_sender
-        )
-    except Exception as e:
-        logger.warning(f"Failed to send WebSocket notification: {e}")
-    
     return message
 
 
@@ -417,133 +400,9 @@ async def mark_messages_read(other_user_id: str, user: dict = Depends(get_curren
         {"$set": {"read": True}}
     )
     
-    # Send read receipt via WebSocket
-    try:
-        if other_user:
-            await ws_manager.send_read_receipt(
-                reader_id=user.get("id"),
-                sender_id=other_user.get("id")
-            )
-    except Exception as e:
-        logger.warning(f"Failed to send read receipt: {e}")
-    
     return {"marked_read": result.modified_count}
 
 
-@router.post("/api/messaging/typing/{receiver_id}")
-async def send_typing_indicator(
-    receiver_id: str,
-    is_typing: bool = True,
-    user: dict = Depends(get_current_user)
-):
-    """Send typing indicator to another user."""
-    try:
-        await ws_manager.send_typing_indicator(
-            sender_id=user["id"],
-            receiver_id=receiver_id,
-            is_typing=is_typing
-        )
-        return {"success": True}
-    except Exception as e:
-        logger.warning(f"Failed to send typing indicator: {e}")
-        return {"success": False}
-
-
-@router.get("/api/messaging/online-users")
-async def get_online_users(user: dict = Depends(get_current_user)):
-    """Get list of online users."""
-    online_users = ws_manager.get_online_users()
-    return {"online_users": online_users}
-
-
-# =============================================================================
-# WebSocket Endpoints for Real-Time Messaging
-# =============================================================================
-
-async def verify_ws_token(token: str) -> Optional[dict]:
-    """Verify JWT token for WebSocket connections."""
-    try:
-        payload = jwt.decode(token, settings.JWT_SECRET, algorithms=["HS256"])
-        user_id = payload.get("user_id")
-        if not user_id:
-            return None
-        user = await db.users.find_one({"id": user_id}, {"_id": 0})
-        return user
-    except Exception:
-        return None
-
-
-@router.websocket("/ws/messaging")
-async def websocket_messaging(
-    websocket: WebSocket,
-    token: str = Query(None)
-):
-    """
-    WebSocket endpoint for real-time messaging.
-    
-    Connect with: ws://host/ws/messaging?token=<jwt_token>
-    
-    Messages received:
-    - {"type": "new_message", "data": {...}} - New message received
-    - {"type": "typing", "data": {"sender_id": "...", "is_typing": true/false}}
-    - {"type": "read_receipt", "data": {"reader_id": "...", "message_ids": [...]}}
-    - {"type": "presence", "data": {"user_id": "...", "is_online": true/false}}
-    
-    Messages to send:
-    - {"type": "ping"} - Keep connection alive
-    - {"type": "typing", "receiver_id": "...", "is_typing": true/false}
-    """
-    # Verify token
-    if not token:
-        await websocket.close(code=4001, reason="Missing token")
-        return
-    
-    user = await verify_ws_token(token)
-    if not user:
-        await websocket.close(code=4001, reason="Invalid token")
-        return
-    
-    user_id = user.get("id")
-    
-    # Accept connection
-    await ws_manager.connect(websocket, user_id)
-    
-    # Broadcast online status
-    try:
-        await ws_manager.send_online_status(user_id, True)
-    except Exception as e:
-        logger.warning(f"Failed to broadcast online status: {e}")
-    
-    try:
-        while True:
-            # Wait for messages from client
-            data = await websocket.receive_json()
-            msg_type = data.get("type")
-            
-            if msg_type == "ping":
-                # Respond to ping with pong
-                await websocket.send_json({"type": "pong"})
-            
-            elif msg_type == "typing":
-                # Forward typing indicator
-                receiver_id = data.get("receiver_id")
-                is_typing = data.get("is_typing", True)
-                if receiver_id:
-                    await ws_manager.send_typing_indicator(user_id, receiver_id, is_typing)
-            
-    except WebSocketDisconnect:
-        logger.info(f"WebSocket disconnected for user {user_id}")
-    except Exception as e:
-        logger.error(f"WebSocket error for user {user_id}: {e}")
-    finally:
-        ws_manager.disconnect(websocket, user_id)
-        # Broadcast offline status
-        try:
-            await ws_manager.send_online_status(user_id, False)
-        except Exception:
-            pass
-
-
 # =============================================================================
 # Maintainer Routes
 # =============================================================================