Update database.py

database.py

@@ -1,18 +1,20 @@
-"""Database module for NBA Buzz"""
+"""Database operations for NBA Buzz"""
 
 import sqlite3
 import json
 from datetime import datetime, timezone, timedelta
-from typing import List, Dict, Optional
-
-DB_PATH = "/tmp/nba_mentions.db"
+from typing import List, Dict
+from nba_players import PLAYER_TEAMS
 
+DB_PATH = "nba_buzz.db"
+_conn = None
 
 def get_conn():
-    conn = sqlite3.connect(DB_PATH)
-    conn.row_factory = sqlite3.Row
-    return conn
-
+    global _conn
+    if _conn is None:
+        _conn = sqlite3.connect(DB_PATH, check_same_thread=False)
+        _conn.row_factory = sqlite3.Row
+    return _conn
 
 def init_db():
     conn = get_conn()
@@ -49,84 +51,85 @@ def init_db():
     except:
         pass
     conn.commit()
-    conn.close()
-
 
-init_db()
+def store_post(post: dict) -> int:
+    conn = get_conn()
+    c = conn.cursor()
+    quote_json = json.dumps(post.get("quote_post")) if post.get("quote_post") else None
+    try:
+        c.execute("""INSERT OR IGNORE INTO posts (uri, author_handle, author_name, author_avatar, text, created_at, web_url, quote_post)
+                     VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+                  (post.get("uri"), post.get("author_handle"), post.get("author_name"), 
+                   post.get("author_avatar"), post.get("text"), post.get("created_at"), 
+                   post.get("web_url"), quote_json))
+        conn.commit()
+        if c.lastrowid:
+            return c.lastrowid
+        c.execute("SELECT id FROM posts WHERE uri = ?", (post.get("uri"),))
+        row = c.fetchone()
+        return row["id"] if row else None
+    except Exception as e:
+        print(f"Error storing post: {e}")
+        return None
+
+def store_mention(post_id: int, player_name: str):
+    if not post_id:
+        return
+    conn = get_conn()
+    c = conn.cursor()
+    team = PLAYER_TEAMS.get(player_name)
+    try:
+        c.execute("INSERT OR IGNORE INTO mentions (post_id, player_name, team_name) VALUES (?, ?, ?)",
+                  (post_id, player_name, team))
+        conn.commit()
+    except Exception as e:
+        print(f"Error storing mention: {e}")
 
+def get_post_count() -> int:
+    conn = get_conn()
+    c = conn.cursor()
+    c.execute("SELECT COUNT(*) FROM posts")
+    return c.fetchone()[0]
 
-def process_and_store_posts(posts: List[Dict], player_matcher_module, get_player_team_func) -> tuple:
-    posts_added = 0
-    mentions_added = 0
+def get_mention_count() -> int:
     conn = get_conn()
     c = conn.cursor()
-    
-    print(f"Processing {len(posts)} posts...")
-    
-    for i, post in enumerate(posts):
-        text = post.get("text", "")
-        if not text:
-            continue
-        
-        c.execute("INSERT OR IGNORE INTO posts (uri, author_handle, author_name, author_avatar, text, created_at, web_url, quote_post) VALUES (?,?,?,?,?,?,?,?)",
-            (post.get("uri"), post.get("author_handle"), post.get("author_name"), post.get("author_avatar", ""), text, post.get("created_at"), post.get("web_url"), 
-             json.dumps(post.get("quote_post")) if post.get("quote_post") else None))
-        
-        if c.rowcount > 0:
-            post_id = c.lastrowid
-            posts_added += 1
-            
-            mentions = player_matcher_module.find_player_mentions(text)
-            for player in mentions.keys():
-                team = get_player_team_func(player)
-                c.execute("INSERT OR IGNORE INTO mentions (post_id, player_name, team_name) VALUES (?,?,?)", (post_id, player, team))
-                if c.rowcount > 0:
-                    mentions_added += 1
-        
-        # Progress every 1000 posts
-        if (i + 1) % 1000 == 0:
-            conn.commit()
-            print(f"Processed {i + 1}/{len(posts)} posts ({posts_added} new, {mentions_added} mentions)")
-    
-    conn.commit()
-    conn.close()
-    print(f"Done: {posts_added} posts, {mentions_added} mentions")
-    return posts_added, mentions_added
+    c.execute("SELECT COUNT(*) FROM mentions")
+    return c.fetchone()[0]
 
+def get_unique_player_count() -> int:
+    conn = get_conn()
+    c = conn.cursor()
+    c.execute("SELECT COUNT(DISTINCT player_name) FROM mentions")
+    return c.fetchone()[0]
 
-def get_player_mention_counts(hours: int = 24, limit: int = 50) -> List[Dict]:
+def get_top_players(hours: int = 24, limit: int = 50) -> List[Dict]:
     conn = get_conn()
     c = conn.cursor()
     cutoff = (datetime.now(timezone.utc) - timedelta(hours=hours)).isoformat()
     c.execute("""
-        SELECT m.player_name, m.team_name, COUNT(DISTINCT m.post_id) as mention_count
+        SELECT m.player_name, m.team_name, COUNT(*) as mention_count
         FROM mentions m JOIN posts p ON m.post_id = p.id
         WHERE p.created_at >= ?
         GROUP BY m.player_name
         ORDER BY mention_count DESC
         LIMIT ?
     """, (cutoff, limit))
-    results = [dict(row) for row in c.fetchall()]
-    conn.close()
-    return results
-
+    return [{"player": r["player_name"], "team": r["team_name"], "mentions": r["mention_count"]} for r in c.fetchall()]
 
-def get_team_mention_counts(hours: int = 24, limit: int = 30) -> List[Dict]:
+def get_top_teams(hours: int = 24, limit: int = 30) -> List[Dict]:
     conn = get_conn()
     c = conn.cursor()
     cutoff = (datetime.now(timezone.utc) - timedelta(hours=hours)).isoformat()
     c.execute("""
-        SELECT m.team_name, COUNT(DISTINCT m.post_id) as mention_count
+        SELECT m.team_name, COUNT(*) as mention_count
         FROM mentions m JOIN posts p ON m.post_id = p.id
-        WHERE p.created_at >= ? AND m.team_name != ''
+        WHERE m.team_name IS NOT NULL AND p.created_at >= ?
         GROUP BY m.team_name
         ORDER BY mention_count DESC
         LIMIT ?
     """, (cutoff, limit))
-    results = [dict(row) for row in c.fetchall()]
-    conn.close()
-    return results
-
+    return [{"team": r["team_name"], "mentions": r["mention_count"]} for r in c.fetchall()]
 
 def get_player_recent_mentions(player_name: str, limit: int = 50, hours: int = 168) -> List[Dict]:
     conn = get_conn()
@@ -147,18 +150,16 @@ def get_player_recent_mentions(player_name: str, limit: int = 50, hours: int = 1
             except:
                 pass
         results.append({
-            "author": r["author_name"] or r["author_handle"], 
+            "author": r["author_name"] or r["author_handle"],
             "author_handle": r["author_handle"],
-            "author_avatar": r["author_avatar"], 
-            "text": r["text"], 
-            "created_at": r["created_at"], 
+            "author_avatar": r["author_avatar"],
+            "text": r["text"],
+            "created_at": r["created_at"],
             "url": r["web_url"],
             "quote_post": quote
         })
-    conn.close()
     return results
 
-
 def get_team_recent_mentions(team_name: str, limit: int = 50, hours: int = 168) -> List[Dict]:
     conn = get_conn()
     c = conn.cursor()
@@ -179,54 +180,50 @@ def get_team_recent_mentions(team_name: str, limit: int = 50, hours: int = 168)
                 pass
         results.append({
             "player": r["player_name"],
-            "author": r["author_name"] or r["author_handle"], 
+            "author": r["author_name"] or r["author_handle"],
             "author_handle": r["author_handle"],
-            "author_avatar": r["author_avatar"], 
-            "text": r["text"], 
-            "created_at": r["created_at"], 
+            "author_avatar": r["author_avatar"],
+            "text": r["text"],
+            "created_at": r["created_at"],
             "url": r["web_url"],
             "quote_post": quote
         })
-    conn.close()
     return results
 
-
-def get_database_stats() -> Dict:
+def get_player_latest_mention(player_name: str) -> dict:
+    """Get the most recent mention for a player."""
     conn = get_conn()
     c = conn.cursor()
-    c.execute("SELECT COUNT(*) FROM posts")
-    posts = c.fetchone()[0]
-    c.execute("SELECT COUNT(*) FROM mentions")
-    mentions = c.fetchone()[0]
-    c.execute("SELECT COUNT(DISTINCT player_name) FROM mentions")
-    players = c.fetchone()[0]
-    conn.close()
-    return {"total_posts": posts, "total_mentions": mentions, "unique_players": players}
-
-
-def get_last_update() -> Optional[str]:
-    conn = get_conn()
-    c = conn.cursor()
-    c.execute("SELECT value FROM app_state WHERE key='last_update'")
+    c.execute("""
+        SELECT p.text, p.author_name, p.author_handle, p.created_at
+        FROM mentions m JOIN posts p ON m.post_id = p.id
+        WHERE m.player_name = ?
+        ORDER BY p.created_at DESC LIMIT 1
+    """, (player_name,))
     row = c.fetchone()
-    conn.close()
-    return row[0] if row else None
-
-
-def set_last_update():
-    conn = get_conn()
-    c = conn.cursor()
-    c.execute("INSERT OR REPLACE INTO app_state (key, value) VALUES ('last_update', ?)", 
-              (datetime.now(timezone.utc).isoformat(),))
-    conn.commit()
-    conn.close()
-
-
-def cleanup_old_data(days: int = 3):
+    if row:
+        return {
+            "text": row["text"],
+            "author": row["author_name"] or row["author_handle"],
+            "created_at": row["created_at"]
+        }
+    return None
+
+def get_team_latest_mention(team_name: str) -> dict:
+    """Get the most recent mention for a team."""
     conn = get_conn()
     c = conn.cursor()
-    cutoff = (datetime.now(timezone.utc) - timedelta(days=days)).isoformat()
-    c.execute("DELETE FROM mentions WHERE post_id IN (SELECT id FROM posts WHERE created_at < ?)", (cutoff,))
-    c.execute("DELETE FROM posts WHERE created_at < ?", (cutoff,))
-    conn.commit()
-    conn.close()
+    c.execute("""
+        SELECT p.text, p.author_name, p.author_handle, p.created_at
+        FROM mentions m JOIN posts p ON m.post_id = p.id
+        WHERE m.team_name = ?
+        ORDER BY p.created_at DESC LIMIT 1
+    """, (team_name,))
+    row = c.fetchone()
+    if row:
+        return {
+            "text": row["text"],
+            "author": row["author_name"] or row["author_handle"],
+            "created_at": row["created_at"]
+        }
+    return None