Update src/db_connector.py

src/db_connector.py

@@ -7,40 +7,25 @@ from urllib.parse import urlparse, unquote
 class Database:
     def __init__(self):
         load_dotenv()
-        self.db_uri = os.getenv("DB_URI")
         
-        # ✅ CRITICAL FIX: Use /tmp which is always writable
-        self.local_db_path = "/tmp/chatbot.db"
+        # 🔒 FORCE SAFE PATH: We ignore .env settings for SQLite to prevent permission errors
+        # We use /tmp/ which is ALWAYS writable on Hugging Face/Linux
+        self.db_path = "/tmp/chatbot_v2.db"
+        self.type = "sqlite"
         
-        # Always default to internal DB if URI is missing or fails
-        if not self.db_uri:
-            print(f"⚠️ DB_URI not found. Using safe internal storage: {self.local_db_path}")
-            self.db_uri = f"sqlite:///{self.local_db_path}"
-            self.type = "sqlite"
-            self.db_path = self.local_db_path
-            
-            # Auto-build the user's data every time
-            self._init_sqlite_data()
-        else:
-            parsed = urlparse(self.db_uri)
-            if "sqlite" in parsed.scheme:
-                self.type = "sqlite"
-                self.db_path = parsed.path
-            else:
-                self.type = "mysql"
-                self.host = parsed.hostname
-                self.port = parsed.port or 3306
-                self.user = parsed.username
-                self.password = unquote(parsed.password)
-                self.db_name = parsed.path[1:]
+        print(f"   ⚡ DATABASE PATH FORCED: {self.db_path}")
+
+        # Always rebuild the demo data to ensure it exists
+        self._init_sqlite_data()
 
     def get_connection(self):
         if self.type == "sqlite":
-            # Connect to the Safe Path
+            # Connect to the safe temp file
             conn = sqlite3.connect(self.db_path, check_same_thread=False)
             conn.row_factory = sqlite3.Row
             return conn
         else:
+            # Fallback for MySQL (if you ever switch back)
             return pymysql.connect(
                 host=self.host, user=self.user, password=self.password,
                 database=self.db_name, port=self.port,
@@ -48,20 +33,16 @@ class Database:
             )
 
     def _init_sqlite_data(self):
-        """Creates the User's specific schema inside the Safe Temp folder."""
-        # We REBUILD it on every startup to ensure the schema matches your code.
-        print("⚡ Building Database in /tmp/chatbot.db ...")
-        
-        conn = None
+        """Forces creation of a fresh database with your data."""
         try:
-            conn = sqlite3.connect(self.local_db_path)
+            conn = sqlite3.connect(self.db_path)
             cursor = conn.cursor()
             
-            # 1. Clean old data to avoid conflicts
+            # 1. Wipe clean to remove old errors
             cursor.execute("DROP TABLE IF EXISTS sales")
             cursor.execute("DROP TABLE IF EXISTS employees")
-
-            # 2. Create Your Exact Tables
+            
+            # 2. Create 'employees' (Lowercase, Plural)
             cursor.execute("""
                 CREATE TABLE employees (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -72,6 +53,7 @@ class Database:
                 )
             """)
             
+            # 3. Create 'sales'
             cursor.execute("""
                 CREATE TABLE sales (
                     sale_id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -82,32 +64,37 @@ class Database:
                 )
             """)
 
-            # 3. Insert Your Data
-            cursor.execute("INSERT INTO employees (name, department, salary, hire_date) VALUES ('Alice', 'Sales', 70000, '2023-01-15')")
-            cursor.execute("INSERT INTO employees (name, department, salary, hire_date) VALUES ('Bob', 'Engineering', 90000, '2022-05-20')")
+            # 4. Insert Data
+            data_employees = [
+                ('Alice', 'Sales', 70000, '2023-01-15'),
+                ('Bob', 'Engineering', 90000, '2022-05-20'),
+                ('Charlie', 'Marketing', 60000, '2023-03-10'),
+                ('David', 'Engineering', 95000, '2021-11-05'),
+                ('Eve', 'Sales', 72000, '2023-02-28')
+            ]
+            cursor.executemany("INSERT INTO employees (name, department, salary, hire_date) VALUES (?, ?, ?, ?)", data_employees)
             
             cursor.execute("INSERT INTO sales (employee_id, amount, sale_date) VALUES (1, 500.00, '2023-06-01')")
             cursor.execute("INSERT INTO sales (employee_id, amount, sale_date) VALUES (1, 1200.50, '2023-06-03')")
             
             conn.commit()
-            print("✅ Database Built Successfully!")
+            print("   ✅ Internal Database & Data Built Successfully!")
             
         except Exception as e:
-            print(f"❌ Failed to build database: {e}")
+            print(f"   ❌ FATAL DB ERROR: {e}")
         finally:
             if conn: conn.close()
 
     def run_query(self, query):
         conn = self.get_connection()
         try:
-            if self.type == "mysql":
-                with conn.cursor() as cursor:
-                    cursor.execute(query)
-                    return cursor.fetchall()
-            else:
-                cursor = conn.cursor()
-                cursor.execute(query)
+            cursor = conn.cursor()
+            cursor.execute(query)
+            # Handle different cursor types
+            if self.type == "sqlite":
                 return [dict(row) for row in cursor.fetchall()]
+            else:
+                return cursor.fetchall()
         except Exception as e:
             return [f"Error: {e}"]
         finally:
@@ -117,14 +104,10 @@ class Database:
         conn = self.get_connection()
         try:
             cursor = conn.cursor()
-            if self.type == "sqlite":
-                cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
-                tables = [row[0] for row in cursor.fetchall() if row[0] not in ['sqlite_sequence']]
-            else:
-                cursor.execute("SHOW TABLES")
-                tables = [list(row.values())[0] for row in cursor.fetchall()]
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+            tables = [row[0] for row in cursor.fetchall() if row[0] != 'sqlite_sequence']
             
-            print(f"🔍 TABLES IN DB: {tables}")
+            print(f"   🔍 TABLES FOUND: {tables}")
             return tables
         except Exception as e:
             print(f"Error fetching tables: {e}")
@@ -137,18 +120,12 @@ class Database:
         columns = []
         try:
             cursor = conn.cursor()
-            if self.type == "sqlite":
-                cursor.execute(f"PRAGMA table_info({table_name})")
-                rows = cursor.fetchall()
-                for row in rows:
-                    col_name = row['name'] if isinstance(row, sqlite3.Row) else row[1]
-                    col_type = row['type'] if isinstance(row, sqlite3.Row) else row[2]
-                    columns.append(f"{col_name} ({col_type})")
-            else:
-                cursor.execute(f"DESCRIBE {table_name}")
-                rows = cursor.fetchall()
-                for row in rows:
-                    columns.append(f"{row['Field']} ({row['Type']})")
+            cursor.execute(f"PRAGMA table_info({table_name})")
+            rows = cursor.fetchall()
+            for row in rows:
+                col_name = row['name'] if isinstance(row, sqlite3.Row) else row[1]
+                col_type = row['type'] if isinstance(row, sqlite3.Row) else row[2]
+                columns.append(f"{col_name} ({col_type})")
             return columns
         except Exception as e:
             return []