Intial Deployment

.env.example

@@ -0,0 +1,2 @@
+DATABASE_URL=sqlite+aiosqlite:///./app/app.db
+SECRET_KEY=a_very_secret_key_change_this_in_production # For signing session IDs

.gitignore

@@ -0,0 +1,7 @@
+venv/
+__pycache__/
+*.pyc
+*.db
+*.db-journal
+.env
+*.log

Dockerfile

@@ -0,0 +1,27 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set the working directory in the container
+WORKDIR /code
+
+# Copy the requirements file into the container
+COPY ./requirements.txt /code/requirements.txt
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code into the container
+COPY ./app /code/app
+COPY ./.env /code/.env # Copy .env file - for Hugging Face, use Secrets instead
+
+# Make port 7860 available to the world outside this container (Gradio default)
+EXPOSE 7860
+
+# Ensure the database directory exists if using SQLite relative paths implicitly
+# RUN mkdir -p /code/app
+
+# Command to run the application using uvicorn
+# It will run the FastAPI app instance created in app/main.py
+# Host 0.0.0.0 is important to accept connections from outside the container
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -7,6 +7,11 @@ sdk: docker
 pinned: false
 license: apache-2.0
 short_description: An app demonstrating Gradio, FastAPI, Docker & SQL DB
+app_file: app/main.py
+python_version: 3.12
+port: 7860
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+

app/api.py

@@ -0,0 +1,97 @@
+from fastapi import APIRouter, HTTPException, status, Depends, WebSocket, WebSocketDisconnect
+from fastapi.responses import JSONResponse
+import logging
+
+from . import schemas, crud, auth, models
+from .websocket import manager
+from .dependencies import get_required_current_user
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+@router.post("/register", status_code=status.HTTP_201_CREATED, response_model=models.User)
+async def register_user(user_in: schemas.UserCreate):
+    existing_user = await crud.get_user_by_email(user_in.email)
+    if existing_user:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Email already registered",
+        )
+    hashed_password = auth.get_password_hash(user_in.password)
+    user_id = await crud.create_user(user_in=user_in, hashed_password=hashed_password)
+
+    # Send notification to other connected users
+    notification_msg = schemas.Notification(
+        email=user_in.email,
+        message=f"New user registered: {user_in.email}"
+    ).model_dump_json() # Use model_dump_json for Pydantic v2
+
+    # We broadcast but conceptually exclude the sender.
+    # Since the new user isn't connected via WebSocket *yet* during registration,
+    # we don't have a sender_id from the WebSocket context here.
+    # We can pass the new user_id to prevent potential self-notification if
+    # the WebSocket connection happens very quickly and maps the ID.
+    await manager.broadcast(notification_msg, sender_id=user_id)
+
+    # Return the newly created user's public info
+    # Fetch the user details to return them accurately
+    created_user = await crud.get_user_by_id(user_id)
+    if not created_user:
+         # This case should ideally not happen if create_user is successful
+         raise HTTPException(status_code=500, detail="Failed to retrieve created user")
+
+    # Convert UserInDB to User model for response
+    return models.User(id=created_user.id, email=created_user.email)
+
+
+@router.post("/login", response_model=schemas.Token)
+async def login_for_access_token(form_data: schemas.UserLogin):
+    user = await crud.get_user_by_email(form_data.email)
+    if not user or not auth.verify_password(form_data.password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token = auth.create_session_token(user_id=user.id)
+    return {"access_token": access_token, "token_type": "bearer"}
+
+@router.get("/users/me", response_model=models.User)
+async def read_users_me(current_user: models.User = Depends(get_required_current_user)):
+    # This endpoint now relies on the dependency correctly getting the user from the token
+    # The token needs to be passed to get_required_current_user somehow.
+    # In Gradio's case, we might call this function directly from Gradio's backend
+    # passing the token from gr.State, rather than relying on HTTP Headers/Cookies.
+    # Let's adjust the dependency call when we use it in main.py.
+    return current_user
+
+
+# WebSocket endpoint (can be associated with the main API router or separate)
+@router.websocket("/ws/{user_id_token}")
+async def websocket_endpoint(websocket: WebSocket, user_id_token: str):
+    """
+    WebSocket endpoint. Connects user and listens for messages.
+    The user_id_token is the signed session token from login.
+    """
+    user_id = await auth.get_user_id_from_token(user_id_token)
+    if user_id is None:
+        logger.warning(f"WebSocket connection rejected: Invalid token {user_id_token}")
+        await websocket.close(code=status.WS_1008_POLICY_VIOLATION)
+        return
+
+    await manager.connect(websocket, user_id)
+    try:
+        while True:
+            # Keep connection alive, maybe handle incoming messages if needed later
+            data = await websocket.receive_text()
+            # For now, we just broadcast on registration, not handle client messages
+            logger.debug(f"Received message from {user_id}: {data} (currently ignored)")
+            # Example: await websocket.send_text(f"Message text was: {data}")
+    except WebSocketDisconnect:
+        manager.disconnect(websocket)
+        logger.info(f"WebSocket disconnected for user {user_id}")
+    except Exception as e:
+        manager.disconnect(websocket)
+        logger.error(f"WebSocket error for user {user_id}: {e}")
+        # Optionally close with an error code
+        # await websocket.close(code=status.WS_1011_INTERNAL_ERROR)

app/crud.py

@@ -0,0 +1,22 @@
+from .database import database, users
+from .models import UserInDB
+from .schemas import UserCreate
+from typing import Optional
+
+async def get_user_by_email(email: str) -> Optional[UserInDB]:
+    query = users.select().where(users.c.email == email)
+    result = await database.fetch_one(query)
+    return UserInDB(**result) if result else None
+
+async def create_user(user_in: UserCreate, hashed_password: str) -> int:
+    query = users.insert().values(
+        email=user_in.email,
+        hashed_password=hashed_password
+    )
+    last_record_id = await database.execute(query)
+    return last_record_id
+
+async def get_user_by_id(user_id: int) -> Optional[UserInDB]:
+    query = users.select().where(users.c.id == user_id)
+    result = await database.fetch_one(query)
+    return UserInDB(**result) if result else None

app/database.py

@@ -0,0 +1,47 @@
+import os
+from databases import Database
+from dotenv import load_dotenv
+from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, text
+
+load_dotenv()
+
+DATABASE_URL = os.getenv("DATABASE_URL", "sqlite+aiosqlite:///./app/app.db")
+
+# Use 'check_same_thread': False only for SQLite, it's generally not needed for server DBs
+connect_args = {"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {}
+
+database = Database(DATABASE_URL, connect_args=connect_args)
+metadata = MetaData()
+
+# Define Users table using SQLAlchemy Core (needed for initial setup)
+users = Table(
+    "users",
+    metadata,
+    Column("id", Integer, primary_key=True),
+    Column("email", String, unique=True, index=True, nullable=False),
+    Column("hashed_password", String, nullable=False),
+)
+
+# Create the database and table if they don't exist
+# This synchronous part runs once at startup usually
+engine = create_engine(DATABASE_URL.replace("+aiosqlite", ""), connect_args=connect_args)
+
+# Check if table exists before creating
+# Using a try-except block for robustness across DB engines if needed later
+try:
+    with engine.connect() as connection:
+        connection.execute(text("SELECT 1 FROM users LIMIT 1"))
+    print("Users table already exists.")
+except Exception:
+    print("Users table not found, creating...")
+    metadata.create_all(engine)
+    print("Users table created.")
+
+# Async connect/disconnect functions for FastAPI lifespan events
+async def connect_db():
+    await database.connect()
+    print("Database connection established.")
+
+async def disconnect_db():
+    await database.disconnect()
+    print("Database connection closed.")

app/dependencies.py

@@ -0,0 +1,22 @@
+from fastapi import HTTPException, status, Request # Request may not be needed if token passed directly
+from typing import Optional
+from . import auth
+from .models import User
+
+# This dependency assumes the token is passed somehow,
+# e.g., in headers (less likely from Gradio client code) or as an argument
+# We will adapt how the token is passed from Gradio later.
+async def get_optional_current_user(token: Optional[str] = None) -> Optional[User]:
+    if token:
+        user = await auth.get_current_user_from_token(token)
+        return user
+    return None
+
+async def get_required_current_user(token: Optional[str] = None) -> User:
+    user = await get_optional_current_user(token)
+    if user is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Not authenticated",
+        )
+    return user

app/main.py

@@ -0,0 +1,318 @@
+import gradio as gr
+import httpx # Use httpx for async requests from Gradio backend to API
+import websockets # Use websockets library to connect from Gradio backend
+import asyncio
+import json
+import os
+import logging
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Depends # Import FastAPI itself
+from .api import router as api_router # Import the API router
+from .database import connect_db, disconnect_db
+from . import schemas, auth, dependencies # Import necessary modules
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Base URL for the API (since Gradio runs its own server, even if mounted)
+# Assuming Gradio runs on 7860, FastAPI routes mounted under it
+API_BASE_URL = "http://127.0.0.1:7860/api" # Adjust if needed
+
+# --- FastAPI Lifespan Event ---
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    await connect_db()
+    # Start background task for websocket listening if needed (or handle within component interaction)
+    yield
+    # Shutdown
+    await disconnect_db()
+
+# Create the main FastAPI app instance that Gradio will use
+# We attach our API routes to this instance.
+app = FastAPI(lifespan=lifespan)
+app.include_router(api_router, prefix="/api") # Mount API routes under /api
+
+# --- Gradio UI Definition ---
+
+# Store websocket connection globally (or within a class) for the Gradio app instance
+# This is tricky because Gradio re-runs functions. State management is key.
+# We'll connect the WebSocket *after* login and store the connection task/info in gr.State.
+
+# --- Helper functions for Gradio calling the API ---
+
+async def make_api_request(method: str, endpoint: str, **kwargs):
+    async with httpx.AsyncClient() as client:
+        url = f"{API_BASE_URL}{endpoint}"
+        try:
+            response = await client.request(method, url, **kwargs)
+            response.raise_for_status() # Raise exception for 4xx/5xx errors
+            return response.json()
+        except httpx.RequestError as e:
+            logger.error(f"HTTP Request failed: {e.request.method} {e.request.url} - {e}")
+            return {"error": f"Network error contacting API: {e}"}
+        except httpx.HTTPStatusError as e:
+            logger.error(f"HTTP Status error: {e.response.status_code} - {e.response.text}")
+            try:
+                detail = e.response.json().get("detail", e.response.text)
+            except json.JSONDecodeError:
+                detail = e.response.text
+            return {"error": f"API Error: {detail}"}
+        except Exception as e:
+             logger.error(f"Unexpected error during API call: {e}")
+             return {"error": f"An unexpected error occurred: {str(e)}"}
+
+# --- WebSocket handling within Gradio ---
+
+async def listen_to_websockets(token: str, notification_state: list):
+    """Connects to WS and updates state list when a message arrives."""
+    if not token:
+        logger.warning("WebSocket listener: No token provided.")
+        return notification_state # Return current state if no token
+
+    ws_url_base = API_BASE_URL.replace("http", "ws")
+    ws_url = f"{ws_url_base}/ws/{token}"
+    logger.info(f"Attempting to connect to WebSocket: {ws_url}")
+
+    try:
+        # Add timeout to websocket connection attempt
+        async with asyncio.wait_for(websockets.connect(ws_url), timeout=10.0) as websocket:
+            logger.info(f"WebSocket connected successfully to {ws_url}")
+            while True:
+                try:
+                    message_str = await websocket.recv()
+                    logger.info(f"Received raw message: {message_str}")
+                    message_data = json.loads(message_str)
+                    logger.info(f"Parsed message data: {message_data}")
+
+                    # Ensure it's the expected notification format
+                    if message_data.get("type") == "new_user":
+                         notification = schemas.Notification(**message_data)
+                         # Prepend to show newest first
+                         notification_state.insert(0, notification.message)
+                         logger.info(f"Notification added: {notification.message}")
+                         # Limit state history (optional)
+                         if len(notification_state) > 10:
+                             notification_state.pop()
+                         # IMPORTANT: Need to trigger Gradio update. This function itself
+                         # cannot directly update UI. It modifies the state, and we need
+                         # a gr.update() returned by a Gradio event handler that *reads*
+                         # this state. We use a polling mechanism or a hidden button trick.
+                         # Let's use polling via `every=` parameter in Gradio.
+                         # This function's primary job is just modifying the list.
+                         # We return the modified list, but Gradio needs an event.
+                         # ---> See the use of `gr.Textbox.change` and `every` below.
+
+                except websockets.ConnectionClosedOK:
+                    logger.info("WebSocket connection closed normally.")
+                    break
+                except websockets.ConnectionClosedError as e:
+                    logger.error(f"WebSocket connection closed with error: {e}")
+                    break
+                except json.JSONDecodeError:
+                     logger.error(f"Failed to decode JSON from WebSocket message: {message_str}")
+                except Exception as e:
+                     logger.error(f"Error in WebSocket listener loop: {e}")
+                     # Avoid breaking the loop on transient errors maybe? Add delay?
+                     await asyncio.sleep(1) # Short delay before retrying receive
+    except asyncio.TimeoutError:
+        logger.error(f"WebSocket connection timed out: {ws_url}")
+    except websockets.exceptions.InvalidURI:
+         logger.error(f"Invalid WebSocket URI: {ws_url}")
+    except websockets.exceptions.WebSocketException as e:
+        logger.error(f"WebSocket connection failed: {e}")
+    except Exception as e:
+        logger.error(f"Unexpected error connecting/listening to WebSocket: {e}")
+
+    # Return the state as it is if connection failed or ended
+    # The calling Gradio function will handle this return value.
+    return notification_state
+
+
+# --- Gradio Interface ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    # State variables
+    # Holds the session token after login
+    auth_token = gr.State(None)
+    # Holds user info {id, email} after login
+    user_info = gr.State(None)
+    # Holds the list of notification messages
+    notification_list = gr.State([])
+    # Holds the asyncio task for the WebSocket listener
+    websocket_task = gr.State(None)
+
+    # --- UI Components ---
+    with gr.Tabs() as tabs:
+        # --- Registration Tab ---
+        with gr.TabItem("Register", id="register_tab"):
+            gr.Markdown("## Create a new account")
+            reg_email = gr.Textbox(label="Email", type="email")
+            reg_password = gr.Textbox(label="Password (min 8 chars)", type="password")
+            reg_confirm_password = gr.Textbox(label="Confirm Password", type="password")
+            reg_button = gr.Button("Register")
+            reg_status = gr.Textbox(label="Status", interactive=False)
+
+        # --- Login Tab ---
+        with gr.TabItem("Login", id="login_tab"):
+            gr.Markdown("## Login to your account")
+            login_email = gr.Textbox(label="Email", type="email")
+            login_password = gr.Textbox(label="Password", type="password")
+            login_button = gr.Button("Login")
+            login_status = gr.Textbox(label="Status", interactive=False)
+
+        # --- Welcome Tab (shown after login) ---
+        with gr.TabItem("Welcome", id="welcome_tab", visible=False) as welcome_tab:
+            gr.Markdown("## Welcome!", elem_id="welcome_header")
+            welcome_message = gr.Markdown("", elem_id="welcome_message")
+            logout_button = gr.Button("Logout")
+            gr.Markdown("---") # Separator
+            gr.Markdown("## Real-time Notifications")
+            # Textbox to display notifications, updated periodically
+            notification_display = gr.Textbox(
+                label="New User Alerts",
+                lines=5,
+                max_lines=10,
+                interactive=False,
+                # The `every=1` makes Gradio call the update function every 1 second
+                # This function will read the `notification_list` state
+                every=1
+            )
+
+    # --- Event Handlers ---
+
+    # Registration Logic
+    async def handle_register(email, password, confirm_password):
+        if not email or not password or not confirm_password:
+            return gr.update(value="Please fill in all fields.")
+        if password != confirm_password:
+            return gr.update(value="Passwords do not match.")
+        if len(password) < 8:
+            return gr.update(value="Password must be at least 8 characters long.")
+
+        payload = {"email": email, "password": password}
+        result = await make_api_request("post", "/register", json=payload)
+
+        if "error" in result:
+            return gr.update(value=f"Registration failed: {result['error']}")
+        else:
+            # Optionally switch to login tab after successful registration
+            return gr.update(value=f"Registration successful for {result.get('email')}! Please log in.")
+
+    reg_button.click(
+        handle_register,
+        inputs=[reg_email, reg_password, reg_confirm_password],
+        outputs=[reg_status]
+    )
+
+    # Login Logic
+    async def handle_login(email, password, current_task):
+        if not email or not password:
+            return gr.update(value="Please enter email and password."), None, None, None, gr.update(visible=False), current_task
+
+        payload = {"email": email, "password": password}
+        result = await make_api_request("post", "/login", json=payload)
+
+        if "error" in result:
+            return gr.update(value=f"Login failed: {result['error']}"), None, None, None, gr.update(visible=False), current_task
+        else:
+            token = result.get("access_token")
+            # Fetch user details using the token
+            user_data = await dependencies.get_optional_current_user(token) # Use dependency directly
+
+            if not user_data:
+                 # This shouldn't happen if login succeeded, but check anyway
+                 return gr.update(value="Login succeeded but failed to fetch user data."), None, None, None, gr.update(visible=False), current_task
+
+            # Cancel any existing websocket listener task before starting a new one
+            if current_task and not current_task.done():
+                current_task.cancel()
+                try:
+                    await current_task # Wait for cancellation
+                except asyncio.CancelledError:
+                    logger.info("Previous WebSocket task cancelled.")
+
+            # Start the WebSocket listener task in the background
+            # We pass the notification_list state *object* itself, which the task will modify
+            new_task = asyncio.create_task(listen_to_websockets(token, notification_list.value)) # Pass the list
+
+            # Update state and UI
+            welcome_msg = f"Welcome, {user_data.email}!"
+            # Switch tabs and show welcome message
+            return (
+                gr.update(value="Login successful!"),       # login_status
+                token,                                      # auth_token state
+                user_data.model_dump(),                     # user_info state (store as dict)
+                gr.update(selected="welcome_tab"),          # Switch Tabs
+                gr.update(visible=True),                    # Make welcome tab visible
+                gr.update(value=welcome_msg),               # Update welcome message markdown
+                new_task                                    # websocket_task state
+            )
+
+    login_button.click(
+        handle_login,
+        inputs=[login_email, login_password, websocket_task],
+        outputs=[login_status, auth_token, user_info, tabs, welcome_tab, welcome_message, websocket_task]
+    )
+
+
+    # Function to update the notification display based on the state
+    # This function is triggered by the `every=1` on the notification_display Textbox
+    def update_notification_ui(notif_list_state):
+        # Join the list items into a string for display
+        return "\n".join(notif_list_state)
+
+    notification_display.change( # Use .change with every= setup on the component
+        fn=update_notification_ui,
+        inputs=[notification_list], # Read the state
+        outputs=[notification_display] # Update the component
+    )
+
+
+    # Logout Logic
+    async def handle_logout(current_task):
+         # Cancel the websocket listener task if it's running
+        if current_task and not current_task.done():
+            current_task.cancel()
+            try:
+                await current_task
+            except asyncio.CancelledError:
+                logger.info("WebSocket task cancelled on logout.")
+
+        # Clear state and switch back to login tab
+        return (
+            None,                           # Clear auth_token
+            None,                           # Clear user_info
+            [],                             # Clear notifications
+            None,                           # Clear websocket_task
+            gr.update(selected="login_tab"),# Switch Tabs
+            gr.update(visible=False),       # Hide welcome tab
+            gr.update(value=""),            # Clear welcome message
+            gr.update(value="")             # Clear login status
+        )
+
+    logout_button.click(
+        handle_logout,
+        inputs=[websocket_task],
+        outputs=[
+            auth_token,
+            user_info,
+            notification_list,
+            websocket_task,
+            tabs,
+            welcome_tab,
+            welcome_message,
+            login_status
+        ]
+    )
+
+# Mount the Gradio app onto the FastAPI app at the root
+app = gr.mount_gradio_app(app, demo, path="/")
+
+# If running this file directly (for local testing)
+# Use uvicorn to run the FastAPI app (which now includes Gradio)
+if __name__ == "__main__":
+    import uvicorn
+    # Use port 7860 as Gradio prefers, host 0.0.0.0 for Docker
+    uvicorn.run(app, host="0.0.0.0", port=7860)

app/models.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel, EmailStr
+
+class User(BaseModel):
+    id: int
+    email: EmailStr
+
+class UserInDB(User):
+    hashed_password: str

app/schemas.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, EmailStr, Field
+
+class UserCreate(BaseModel):
+    email: EmailStr
+    password: str = Field(min_length=8)
+
+class UserLogin(BaseModel):
+    email: EmailStr
+    password: str
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+
+class Notification(BaseModel):
+    type: str = "new_user"
+    email: EmailStr
+    message: str

app/websocket.py

@@ -0,0 +1,66 @@
+from fastapi import WebSocket
+from typing import List, Dict, Optional
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ConnectionManager:
+    def __init__(self):
+        # Store connections with user ID if available for targeted messaging later
+        self.active_connections: Dict[Optional[int], List[WebSocket]] = {}
+        # Map websocket to user_id for easier removal
+        self.websocket_to_user: Dict[WebSocket, Optional[int]] = {}
+
+    async def connect(self, websocket: WebSocket, user_id: Optional[int] = None):
+        await websocket.accept()
+        if user_id not in self.active_connections:
+            self.active_connections[user_id] = []
+        self.active_connections[user_id].append(websocket)
+        self.websocket_to_user[websocket] = user_id
+        logger.info(f"WebSocket connected: {websocket.client.host}:{websocket.client.port}, User ID: {user_id}")
+        logger.info(f"Total connections: {sum(len(conns) for conns in self.active_connections.values())}")
+
+
+    def disconnect(self, websocket: WebSocket):
+        user_id = self.websocket_to_user.pop(websocket, None)
+        if user_id in self.active_connections:
+            try:
+                self.active_connections[user_id].remove(websocket)
+                if not self.active_connections[user_id]:
+                    del self.active_connections[user_id]
+            except ValueError:
+                logger.warning(f"WebSocket not found in active list for user {user_id} during disconnect.")
+
+        logger.info(f"WebSocket disconnected: {websocket.client.host}:{websocket.client.port}, User ID: {user_id}")
+        logger.info(f"Total connections: {sum(len(conns) for conns in self.active_connections.values())}")
+
+
+    async def broadcast(self, message: str, sender_id: Optional[int] = None):
+        disconnected_websockets = []
+        # Iterate through all connections
+        all_websockets = [ws for user_conns in self.active_connections.values() for ws in user_conns]
+        logger.info(f"Broadcasting to {len(all_websockets)} connections (excluding sender if ID matches). Sender ID: {sender_id}")
+
+        for websocket in all_websockets:
+             # Send to all *other* users (or all if sender_id is None)
+            ws_user_id = self.websocket_to_user.get(websocket)
+            # Requirement: "all *other* connected users should see"
+            # Send if the websocket isn't associated with the sender_id
+            # (Note: If a user has multiple tabs/connections open, they might still receive it
+            # if the sender_id check only excludes one specific connection. This simple broadcast
+            # targets users based on their ID at connection time).
+            # Let's refine: Send if the user_id associated with the WS is not the sender_id
+            if ws_user_id != sender_id:
+                try:
+                    await websocket.send_text(message)
+                    logger.debug(f"Message sent to user {ws_user_id}")
+                except Exception as e:
+                    logger.error(f"Error sending message to websocket {websocket.client}: {e}. Marking for disconnect.")
+                    disconnected_websockets.append(websocket)
+
+        # Clean up connections that failed during broadcast
+        for ws in disconnected_websockets:
+            self.disconnect(ws)
+
+manager = ConnectionManager()

requirements.txt

@@ -0,0 +1,11 @@
+fastapi==0.111.0
+uvicorn[standard]==0.29.0
+gradio==4.29.0
+passlib[bcrypt]==1.7.4
+python-dotenv==1.0.1
+databases[sqlite]==0.9.0 # Async DB access
+sqlalchemy==2.0.29       # Core needed by `databases` or for potential future use
+pydantic==2.7.1
+python-multipart==0.0.9 # For form data in FastAPI
+itsdangerous==2.1.2     # Simple secure signing for session IDs
+websockets>=11.0.3,<13.0 # Ensure compatibility