Debug

app/database.py

@@ -2,8 +2,8 @@
 import os
 from databases import Database
 from dotenv import load_dotenv
-# --- ADD THIS IMPORT ---
-from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, text, exc as sqlalchemy_exc
+# --- Keep only these SQLAlchemy imports ---
+from sqlalchemy import MetaData, Table, Column, Integer, String
 import logging
 from urllib.parse import urlparse, urlunparse, parse_qs, urlencode
 
@@ -14,7 +14,6 @@ logger = logging.getLogger(__name__)
 DEFAULT_DB_PATH = "/tmp/app.db" # Store DB in the temporary directory
 raw_db_url = os.getenv("DATABASE_URL", f"sqlite+aiosqlite:///{DEFAULT_DB_PATH}")
 
-# --- URL Parsing and Async Database setup (remains the same) ---
 final_database_url = raw_db_url
 if raw_db_url.startswith("sqlite+aiosqlite"):
     parsed_url = urlparse(raw_db_url)
@@ -27,7 +26,10 @@ if raw_db_url.startswith("sqlite+aiosqlite"):
 else:
     logger.info(f"Using non-SQLite async DB URL: {final_database_url}")
 
+# --- Async Database Instance ---
 database = Database(final_database_url)
+
+# --- Metadata and Table Definition (Still needed for DDL generation) ---
 metadata = MetaData()
 users = Table(
     "users",
@@ -37,92 +39,46 @@ users = Table(
     Column("hashed_password", String, nullable=False),
 )
 
-# --- Synchronous Engine for Initial Table Creation ---
-sync_db_url = final_database_url.replace("+aiosqlite", "")
-logger.info(f"Using synchronous DB URL for initial check/create: {sync_db_url}")
-engine = create_engine(sync_db_url)
-
-# --- Directory and Table Creation Logic ---
-db_file_path = ""
-if sync_db_url.startswith("sqlite"):
-    path_part = sync_db_url.split("sqlite:///")[-1].split("?")[0]
-    db_file_path = path_part # Should be /tmp/app.db
-
-if db_file_path:
-    db_dir = os.path.dirname(db_file_path) # Should be /tmp
-    logger.info(f"Checking database directory: {db_dir}")
-    try:
-        if not os.path.exists(db_dir):
-             logger.error(f"CRITICAL: Directory {db_dir} does not exist!")
-        elif not os.access(db_dir, os.W_OK):
-            logger.error(f"CRITICAL: Directory {db_dir} is not writable! Cannot create database.")
-        else:
-            logger.info(f"Database directory {db_dir} appears writable.")
-    except OSError as e:
-        logger.error(f"Error accessing database directory {db_dir}: {e}")
-    except Exception as e:
-        logger.error(f"Unexpected error checking directory {db_dir}: {e}")
-
-
-# --- Refined Synchronous Table Check/Creation ---
-try:
-    logger.info("Attempting sync connection to check/create table...")
-    with engine.connect() as connection:
-        logger.info("Sync engine connection successful.")
-        try:
-            # Check if table exists
-            connection.execute(text("SELECT 1 FROM users LIMIT 1"))
-            logger.info("Users table already exists (checked via sync connection).")
-        # --- Catch specific SQLAlchemy error ---
-        except sqlalchemy_exc.OperationalError as table_missing_err:
-             # Check if the error message specifically indicates "no such table"
-             if "no such table" in str(table_missing_err).lower():
-                 logger.warning("Users table not found (expected), attempting creation...")
-                 try:
-                     # Begin a transaction explicitly (optional, connect() usually does)
-                     # with connection.begin(): # Alternative way to manage transaction
-                     # Use the connection object for create_all
-                     metadata.create_all(bind=connection) # <-- Bind to connection
-                     # --- Explicitly commit ---
-                     connection.commit()
-                     logger.info("Users table creation attempted and committed via sync connection.")
-                     # --- Verify creation immediately ---
-                     try:
-                          connection.execute(text("SELECT 1 FROM users LIMIT 1"))
-                          logger.info("Users table successfully verified immediately after creation.")
-                     except Exception as verify_err:
-                          logger.error(f"Failed to verify table immediately after creation: {verify_err}")
-
-                 except Exception as creation_err:
-                      logger.exception(f"Error during table creation or commit: {creation_err}")
-                      # Optionally rollback? connection.rollback()
-
-             else:
-                 # Log other OperationalErrors during the check phase
-                 logger.error(f"OperationalError during table check (but not 'no such table'): {table_missing_err}")
-                 raise # Re-raise unexpected errors
-
-        except Exception as table_check_exc: # Catch other unexpected errors during check
-             logger.error(f"Unexpected error during table check: {type(table_check_exc).__name__}: {table_check_exc}")
-             raise # Re-raise unexpected errors
+# --- REMOVE ALL SYNCHRONOUS ENGINE AND TABLE CREATION LOGIC ---
 
-except Exception as e:
-    # Errors connecting, or unexpected errors during check/create phase
-    logger.exception(f"CRITICAL: Failed during sync connection or table setup: {e}")
-
-
-# --- Async connect/disconnect functions (remain the same) ---
+# --- Keep and refine Async connect/disconnect functions ---
 async def connect_db():
+    """Connects to the database, ensuring the parent directory exists."""
     try:
+        # Ensure the directory exists just before connecting
+        db_file_path = final_database_url.split("sqlite:///")[-1].split("?")[0]
+        db_dir = os.path.dirname(db_file_path)
+        if db_dir: # Only proceed if a directory path was found
+             if not os.path.exists(db_dir):
+                 logger.info(f"Database directory {db_dir} does not exist. Attempting creation...")
+                 try:
+                     os.makedirs(db_dir, exist_ok=True)
+                     logger.info(f"Created database directory {db_dir}.")
+                 except Exception as mkdir_err:
+                     # Log error but proceed, connection might still work if path is valid but dir creation failed weirdly
+                     logger.error(f"Failed to create directory {db_dir}: {mkdir_err}")
+             # Check writability after ensuring existence attempt
+             if os.path.exists(db_dir) and not os.access(db_dir, os.W_OK):
+                  logger.error(f"CRITICAL: Directory {db_dir} exists but is not writable!")
+             elif not os.path.exists(db_dir):
+                  logger.error(f"CRITICAL: Directory {db_dir} does not exist and could not be created!")
+
+
+        # Now attempt connection
         await database.connect()
         logger.info(f"Database connection established (async): {final_database_url}")
+        # Table creation will happen in main.py lifespan event using this connection
     except Exception as e:
         logger.exception(f"Failed to establish async database connection: {e}")
-        raise
+        raise # Reraise critical error during startup
 
 async def disconnect_db():
+    """Disconnects from the database if connected."""
     try:
-        await database.disconnect()
-        logger.info("Database connection closed (async).")
+        if database.is_connected:
+             await database.disconnect()
+             logger.info("Database connection closed (async).")
+        else:
+             logger.info("Database already disconnected (async).")
     except Exception as e:
         logger.exception(f"Error closing async database connection: {e}")

app/main.py

@@ -1,6 +1,7 @@
+# app/main.py
 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 httpx
+import websockets
 import asyncio
 import json
 import os
@@ -8,27 +9,72 @@ 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
+# --- Import necessary items from database.py ---
+from .database import connect_db, disconnect_db, database, metadata, users
+from .api import router as api_router
+from . import schemas, auth, dependencies
+
+# --- Import SQLAlchemy helpers for DDL generation ---
+from sqlalchemy.schema import CreateTable
+from sqlalchemy.dialects import sqlite # Assuming SQLite, adjust if needed
 
 # 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
+# Base URL for the API
 API_BASE_URL = "http://127.0.0.1:7860/api" # Adjust if needed
 
 # --- FastAPI Lifespan Event ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     # Startup
+    logger.info("Application startup: Connecting DB...")
     await connect_db()
-    # Start background task for websocket listening if needed (or handle within component interaction)
+    logger.info("Application startup: DB Connected. Checking/Creating tables...")
+    if database.is_connected: # Proceed only if connection succeeded
+        try:
+            # 1. Check if table exists using the async connection
+            # For SQLite, check the sqlite_master table
+            check_query = "SELECT name FROM sqlite_master WHERE type='table' AND name=:table_name;"
+            table_exists = await database.fetch_one(query=check_query, values={"table_name": users.name})
+
+            if not table_exists:
+                logger.info(f"Table '{users.name}' not found, attempting creation using async connection...")
+
+                # 2. Generate the CREATE TABLE statement using SQLAlchemy DDL compiler
+                # We need a dialect object for the compiler
+                # Infer dialect from the database URL if possible, default to SQLite for this example
+                dialect = sqlite.dialect() # Or determine dynamically based on database.url
+                create_table_stmt = str(CreateTable(users).compile(dialect=dialect))
+                logger.debug(f"Generated CREATE TABLE statement: {create_table_stmt}")
+
+                # 3. Execute the CREATE TABLE statement via the async database connection
+                await database.execute(query=create_table_stmt)
+                logger.info(f"Table '{users.name}' created successfully via async connection.")
+
+                # 4. Optional: Verify again immediately
+                table_exists_after = await database.fetch_one(query=check_query, values={"table_name": users.name})
+                if table_exists_after:
+                     logger.info(f"Table '{users.name}' verified after creation.")
+                else:
+                     logger.error(f"Table '{users.name}' verification FAILED after creation attempt!")
+
+            else:
+                logger.info(f"Table '{users.name}' already exists (checked via async connection).")
+
+        except Exception as db_setup_err:
+            logger.exception(f"CRITICAL error during async DB table setup: {db_setup_err}")
+            # Consider whether to halt startup here depending on severity
+    else:
+        logger.error("CRITICAL: Database connection failed, skipping table setup.")
+
+    logger.info("Application startup: DB setup phase complete.")
     yield
     # Shutdown
+    logger.info("Application shutdown: Disconnecting DB...")
     await disconnect_db()
+    logger.info("Application shutdown: DB Disconnected.")
 
 # Create the main FastAPI app instance that Gradio will use
 # We attach our API routes to this instance.