Deploy from GitHub Actions (2026-03-12 18:14 UTC)

app/main.py

@@ -14,7 +14,7 @@ from pydantic import BaseModel
 from app.utils.config import get_config, get_logger, get_version
 from app.models.nlp_engine import NLPEngine
 from app.models.conversation_manager import ConversationManager
-from app.models.database import init_database, get_database, User, Conversation, Message
+from app.models.database import init_database, health_check as db_health_check
 from app.models.smart_models import UserPreference, UserInsight, ConversationTopic
 from app.data.training_data import TRAINING_DATA
 from app.routers import knowledge_base
@@ -34,13 +34,14 @@ async def lifespan(fastapi_app: FastAPI):  # pylint: disable=unused-argument
 
     # Initialize database
     try:
-        db = init_database()
-        if db.health_check():
+        init_database()
+
+        if db_health_check():
             logger.info("Database connection established successfully")
         else:
             logger.warning("Database health check failed, but continuing...")
-    except Exception as e:
-        logger.error("Database initialization failed: %s", str(e))
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        logger.error("Database initialization failed: %s: %s", type(e).__name__, str(e))
         logger.warning("Continuing without database - some features may not work...")
 
     # Train NLP model
@@ -101,7 +102,7 @@ async def health_check():
     logger.debug("Health check endpoint accessed")
 
     # Check database health
-    db_status = "healthy" if get_database().health_check() else "unhealthy"
+    db_status = "healthy" if db_health_check() else "unhealthy"
 
     return {
         "status": "healthy",
@@ -190,7 +191,7 @@ async def chat(request: ChatRequest):
                 "threshold_applied": confidence < config.nlp["confidence_threshold"],
                 "environment": config.env.name,
                 "response_time_ms": response_time_ms,
-                "database_enabled": get_database().health_check(),
+                "database_enabled": db_health_check(),
             }
 
         logger.info("Chat response generated successfully for session %s", session_id)

app/models/conversation_manager.py

@@ -8,7 +8,7 @@ from groq import Groq
 
 # Absolute imports from project root
 from app.utils.config import get_logger
-from app.models.database import get_database, User, Conversation, Message
+from app.models.database import User, Conversation, Message, SessionLocal
 from app.models.information_extractor import InformationExtractor
 
 
@@ -16,7 +16,6 @@ class ConversationManager:
     def __init__(self, config=None):
         self.config = config
         self.logger = get_logger(__name__)
-        self.db = get_database()
         self.info_extractor = InformationExtractor()
 
         max_history = config.nlp["max_history"] if config else 50
@@ -28,7 +27,7 @@ class ConversationManager:
 
     def get_or_create_user(self, session_id: str) -> User:
         """Get existing user or create new one"""
-        with self.db.get_session() as db_session:
+        with SessionLocal() as db_session:
             user = db_session.query(User).filter(User.session_id == session_id).first()
 
             if not user:
@@ -46,7 +45,7 @@ class ConversationManager:
 
     def get_active_conversation(self, user: User) -> Optional[Conversation]:
         """Get the most recent active conversation for a user"""
-        with self.db.get_session() as db_session:
+        with SessionLocal() as db_session:
             # Refresh user object in this session
             user = db_session.merge(user)
 
@@ -81,7 +80,7 @@ class ConversationManager:
 
     def create_conversation(self, user: User) -> Conversation:
         """Create a new conversation for the user"""
-        with self.db.get_session() as db_session:
+        with SessionLocal() as db_session:
             # Refresh user object in this session
             user = db_session.merge(user)
 
@@ -97,7 +96,7 @@ class ConversationManager:
         self, conversation: Conversation, limit: int = 5
     ) -> List[Dict]:
         """Get recent messages from conversation for context"""
-        with self.db.get_session() as db_session:
+        with SessionLocal() as db_session:
             # Refresh conversation object in this section
             conversation = db_session.merge(conversation)
 
@@ -178,7 +177,7 @@ class ConversationManager:
 
                 # Update user's preferred language
                 if user and user.preferred_language != language:
-                    with self.db.get_session() as db_session:
+                    with SessionLocal() as db_session:
                         user = db_session.merge(user)
                         user.preferred_language = language
                         db_session.commit()
@@ -233,7 +232,7 @@ class ConversationManager:
                 conversation = self.create_conversation(user)
 
             # Create message record
-            with self.db.get_session() as db_session:
+            with SessionLocal() as db_session:
                 # Refresh objects in this session
                 conversation = db_session.merge(conversation)
                 user = db_session.merge(user)
@@ -275,7 +274,7 @@ class ConversationManager:
     def get_conversation_history(self, session_id: str) -> List[Dict]:
         """Get conversation history for a session (for analytics endpoint)"""
         try:
-            with self.db.get_session() as db_session:
+            with SessionLocal() as db_session:
                 user = (
                     db_session.query(User).filter(User.session_id == session_id).first()
                 )
@@ -316,7 +315,7 @@ class ConversationManager:
     def get_user_stats(self, session_id: str) -> Dict:
         """Get user statistics"""
         try:
-            with self.db.get_session() as db_session:
+            with SessionLocal() as db_session:
                 user = (
                     db_session.query(User).filter(User.session_id == session_id).first()
                 )

app/models/database.py

@@ -1,5 +1,4 @@
 # app/models/database.py
-import os
 from datetime import datetime, timezone
 import uuid
 from sqlalchemy import (
@@ -19,12 +18,23 @@ from sqlalchemy.orm import sessionmaker, relationship, declarative_base
 from sqlalchemy.dialects.postgresql import UUID
 
 # Absolute import from project root
-from app.utils.config import get_logger
+from app.utils.config import get_logger, config_manager
+
+config = config_manager.get_config()
 
 logger = get_logger(__name__)
 
 Base = declarative_base()
 
+engine = create_engine(
+    config.database_url,
+    echo=False,  # Set to True for SQL debugging
+    pool_pre_ping=True,  # Verify connections before use
+    pool_recycle=300,  # Recycle connections every 5 minutes
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
 
 class User(Base):
     __tablename__ = "users"
@@ -105,90 +115,28 @@ class Message(Base):
         return f"<Message(id={self.id}, intent={self.intent}, confidence={self.confidence})>"
 
 
-class Database:
-    def __init__(self, database_url=None):
-        self.database_url = database_url or os.getenv("DATABASE_URL")
-
-        if not self.database_url:
-            raise ValueError("DATABASE_URL environment variable is required")
-
-        # Create engine
-        self.engine = create_engine(
-            self.database_url,
-            echo=False,  # Set to True for SQL debugging
-            pool_pre_ping=True,  # Verify connections before use
-            pool_recycle=300,  # Recycle connections every 5 minutes
-        )
-
-        # Create session factory
-        self.SessionLocal = sessionmaker(
-            autocommit=False, autoflush=False, bind=self.engine
-        )
-
-        logger.info(
-            "Database manager initialized with URL: %s",
-            self.database_url.split("@")[0] + "@***",
-        )
-
-    def create_tables(self):
-        """Create all tables in the database"""
-        Base.metadata.create_all(bind=self.engine)
-        logger.info("Database tables created successfully")
-
-    def get_session(self):
-        """Get a database session"""
-        return self.SessionLocal()
-
-    def health_check(self):
-        """Check if database connection is working"""
-        try:
-            with self.get_session() as session:
-                from sqlalchemy import text
-
-                session.execute(text("SELECT 1"))
-            logger.info("Database health check passed")
-            return True
-        except Exception as e:
-            logger.error("Database health check failed: %s", str(e))
-            return False
-
-
-class DatabaseManager:
-    """Singleton database manager"""
-
-    def __init__(self):
-        self.db = None
-
-    def get_database(self) -> Database:
-        """Get the database instance (create if doesn't exist)"""
-        if self.db is None:
-            self.db = Database()
-        return self.db
-
-    def init_database(self):
-        """Initialize the database instance and create tables"""
-        db = self.get_database()
-        db.create_tables()
-        return db
-
-
-# Create single instance of DatabaseManager
-db_manager = DatabaseManager()
-
+def init_database():
+    # create all tables in the database
+    Base.metadata.create_all(bind=engine)
+    logger.info("Database tables created successfully")
 
-# Convenience functions for easier imports
-def get_database() -> DatabaseManager:
-    """Get the global database manager instance"""
-    return db_manager.get_database()
 
+def health_check():
+    """Check if database connection is working"""
+    try:
+        with SessionLocal() as session:
+            from sqlalchemy import text  # pylint: disable=import-outside-toplevel
 
-def init_database():
-    """Initialize the global database manager instance and create tables"""
-    return db_manager.init_database()
+            session.execute(text("SELECT 1"))
+        logger.info("Database health check passed")
+        return True
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        logger.error("Database health check failed: %s: %s", type(e).__name__, str(e))
+        return False
 
 
 def get_db():
-    db = get_database().get_session()
+    db = SessionLocal()
     try:
         yield db
     finally:

app/utils/config.py

@@ -172,6 +172,9 @@ class Config:
         self.llm_api_key = os.getenv("GROQ_API_KEY", "")
         self.system_prompt = os.getenv("SYSTEM_PROMPT", "")
 
+        # Database Configuration
+        self.database_url = os.getenv("DATABASE_URL", "")
+
     def _setup_logging(self):
         """Configure logging for the entire application"""
         # Create logger