Update database.py

database.py

@@ -1,99 +1,50 @@
-import sqlite3
 import os
+import sqlite3
 from flask import g
-from datetime import datetime, timedelta
 
-def get_db():
-    """Get database connection with retry logic"""
-    if 'db' not in g:
-        max_retries = 3
-        for attempt in range(max_retries):
-            try:
-                g.db = sqlite3.connect(os.getenv('DATABASE_URL', '/app/data/news.db'))
-                g.db.row_factory = sqlite3.Row
-                # Enable WAL mode for better concurrency
-                g.db.execute('PRAGMA journal_mode=WAL')
-                g.db.execute('PRAGMA synchronous=NORMAL')
-                break
-            except sqlite3.Error as e:
-                if attempt == max_retries - 1:
-                    raise
-                time.sleep(2)
-    return g.db
+class Database:
+    def __init__(self, db_url):
+        self.db_url = db_url
+        self.conn = None
 
-def init_db(app):
-    """Initialize database with tables"""
-    with app.app_context():
-        max_retries = 3
-        for attempt in range(max_retries):
-            try:
-                db = get_db()
-                db.execute('''
-                    CREATE TABLE IF NOT EXISTS news (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        title TEXT NOT NULL,
-                        source TEXT NOT NULL,
-                        published TEXT NOT NULL,
-                        url TEXT UNIQUE NOT NULL,
-                        summary TEXT NOT NULL,
-                        content TEXT NOT NULL,
-                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                db.execute('CREATE INDEX IF NOT EXISTS idx_timestamp ON news(timestamp)')
-                db.commit()
-                break
-            except sqlite3.Error as e:
-                if attempt == max_retries - 1:
-                    raise
-                time.sleep(2)
+    def get_db(self):
+        if not self.conn:
+            self.conn = sqlite3.connect(self.db_url)
+            self.conn.row_factory = sqlite3.Row
+        return self.conn
 
-def close_db(e=None):
-    """Close database connection"""
-    db = g.pop('db', None)
-    if db is not None:
-        db.close()
+    def close_db(self):
+        if self.conn:
+            self.conn.close()
+            self.conn = None
 
-def cleanup_db():
-    """Remove old entries and optimize database"""
-    try:
-        db = get_db()
-        # Keep only the last 100 articles
-        db.execute('DELETE FROM news WHERE id NOT IN (SELECT id FROM news ORDER BY timestamp DESC LIMIT 100)')
+    def init_db(self):
+        db = self.get_db()
+        with open('schema.sql', 'r') as f:
+            db.cursor().executescript(f.read())
         db.commit()
-        db.execute('VACUUM')
-    except Exception as e:
-        app.logger.error(f"Database cleanup failed: {str(e)}")
 
-def cache_news(articles):
-    """Cache news articles in database"""
-    try:
-        db = get_db()
-        db.execute('BEGIN TRANSACTION')
+    def cache_news(self, articles):
+        db = self.get_db()
         for article in articles:
-            db.execute('''
-                INSERT OR IGNORE INTO news 
-                (title, source, published, url, summary, content)
-                VALUES (?, ?, ?, ?, ?, ?)
-            ''', (
-                article['title'],
-                article['source'],
-                article['published'],
-                article['url'],
-                article['summary'],
-                article['content']
-            ))
+            try:
+                db.execute('''
+                    INSERT OR IGNORE INTO news 
+                    (title, source, published, url, summary, content)
+                    VALUES (?,?,?,?,?,?)
+                ''', (
+                    article['title'],
+                    article['source'],
+                    article['published'],
+                    article['url'],
+                    article['summary'],
+                    article['content']
+                ))
+            except sqlite3.IntegrityError:
+                continue
         db.commit()
-    except Exception as e:
-        db.rollback()
-        raise e
 
-def get_cached_news(limit=15):
-    """Get cached news articles"""
-    try:
-        db = get_db()
-        cur = db.execute('SELECT * FROM news ORDER BY timestamp DESC LIMIT ?', (limit,))
-        return [dict(row) for row in cur.fetchall()]
-    except Exception as e:
-        app.logger.error(f"Error fetching cached news: {str(e)}")
-        return []
+    def get_cached_news(self):
+        db = self.get_db()
+        cur = db.execute('SELECT * FROM news ORDER BY timestamp DESC LIMIT 15')
+        return [dict(row) for row in cur.fetchall()]