GameSentenceMiner 2.18.20__py3-none-any.whl → 2.19.0__py3-none-any.whl

GameSentenceMiner/util/get_overlay_coords.py

@@ -83,6 +83,8 @@ try:
 except ImportError:
     mss = None
     
+overlay_processor = None
+    
 class OverlayThread(threading.Thread):
     """
     A thread to run the overlay processing loop.
@@ -91,7 +93,6 @@ class OverlayThread(threading.Thread):
     """
     def __init__(self):
         super().__init__()
-        self.overlay_processor = OverlayProcessor()
         self.loop = asyncio.new_event_loop()
         self.daemon = True
         self.first_time_run = True
@@ -106,10 +107,10 @@ class OverlayThread(threading.Thread):
         while True:
             if overlay_server_thread.has_clients():
                 if get_config().overlay.periodic:
-                    await self.overlay_processor.find_box_and_send_to_overlay('', True)
+                    await overlay_processor.find_box_and_send_to_overlay('', True)
                     await asyncio.sleep(get_config().overlay.periodic_interval)
                 elif self.first_time_run:
-                    await self.overlay_processor.find_box_and_send_to_overlay('', False)
+                    await overlay_processor.find_box_and_send_to_overlay('', False)
                     self.first_time_run = False
                 else:
                     await asyncio.sleep(3)
@@ -569,7 +570,26 @@ class OverlayProcessor:
         # logger.info(f"Converted OneOCR results to percentages: {converted_results}")
         return converted_results
     
-overlay_processor = OverlayProcessor()
+async def init_overlay_processor():
+    """
+    Initializes the overlay processor and starts the overlay thread.
+    This function can be called at application startup.
+    """
+    global overlay_processor
+    overlay_processor = OverlayProcessor()
+    overlay_thread = OverlayThread()
+    overlay_thread.start()
+    logger.info("Overlay processor initialized and thread started.")
+    
+    
+def get_overlay_processor() -> OverlayProcessor:
+    """
+    Returns the initialized overlay processor instance.
+    """
+    global overlay_processor
+    if overlay_processor is None:
+        asyncio.run(init_overlay_processor())
+    return overlay_processor
 
 async def main_test_screenshot():
     """

GameSentenceMiner/web/events.py

@@ -1,16 +1,7 @@
-import asyncio
-from collections import defaultdict
 import datetime
-import json
-import os
-import queue
-import sqlite3
-import threading
 from dataclasses import dataclass
 
-from GameSentenceMiner.util.db import GameLinesTable
-from GameSentenceMiner.util.text_log import GameLine, initial_time
-from GameSentenceMiner.util.configuration import logger, DB_PATH
+from GameSentenceMiner.util.text_log import GameLine
 
 
 @dataclass
@@ -42,60 +33,30 @@ class EventItem:
 
 
 class EventManager:
+    ids: set[str] = set()
     events: list[EventItem]
     events_dict: dict[str, EventItem] = {}
 
     def __init__(self):
         self.events = []
-        self.ids = []
+        self.ids = set()
+        self.timed_out_ids = set()
         self.events_dict = {}
-        self._connect()
-        self._create_table()
-        self._load_events_from_db()
-        # self.close_connection()
-
-    def _connect(self):
-        self.conn = sqlite3.connect(DB_PATH)
-        self.cursor = self.conn.cursor()
-
-    def _create_table(self):
-        self.cursor.execute("""
-            CREATE TABLE IF NOT EXISTS events (
-                event_id TEXT PRIMARY KEY,
-                line_id TEXT,
-                text TEXT,
-                time TEXT
-            )
-        """)
-        self.conn.commit()
-
-    def _load_events_from_db(self):
-        self.cursor.execute("SELECT * FROM events")
-        rows = self.cursor.fetchall()
-        for row in rows:
-            event_id, line_id, text, timestamp = row
-            timestamp = datetime.datetime.fromisoformat(timestamp)
-            line = GameLine(line_id, text, timestamp, None, None, 0)
-            event = EventItem(line, event_id, text, timestamp,
-                              False, timestamp < initial_time)
-            self.events.append(event)
-            self.ids.append(event_id)
-            self.events_dict[event_id] = event
 
     def __iter__(self):
         return iter(self.events)
 
     def replace_events(self, new_events: list[EventItem]):
         self.events = new_events
+        self.events_dict = {event.id: event for event in new_events}
+        self.ids = {event.id for event in new_events}
 
     def add_gameline(self, line: GameLine):
         new_event = EventItem(line, line.id, line.text,
                               line.time, False, False)
         self.events_dict[line.id] = new_event
-        self.ids.append(line.id)
+        self.ids.add(line.id)
         self.events.append(new_event)
-        # self.store_to_db(new_event)
-        # event_queue.put(new_event)
         return new_event
 
     def reset_checked_lines(self):
@@ -107,8 +68,7 @@ class EventManager:
 
     def add_event(self, event):
         self.events.append(event)
-        self.ids.append(event.id)
-        event_queue.put(event)
+        self.ids.add(event.id)
 
     def get(self, event_id):
         return self.events_dict.get(event_id)
@@ -116,63 +76,27 @@ class EventManager:
     def get_ids(self):
         return self.ids
 
-    def close_connection(self):
-        if self.conn:
-            self.conn.close()
-
     def clear_history(self):
-        self.cursor.execute("DELETE FROM events WHERE time < ?",
-                            (initial_time.isoformat(),))
-        logger.info(f"Cleared history before {initial_time.isoformat()}")
-        self.conn.commit()
-        # Clear the in-memory events as well
-        event_manager.events = [
-            event for event in event_manager if not event.history]
-        event_manager.events_dict = {
-            event.id: event for event in event_manager.events}
-
-
-class EventProcessor(threading.Thread):
-    def __init__(self, event_queue, db_path):
-        super().__init__()
-        self.event_queue = event_queue
-        self.db_path = db_path
-        self.conn = None
-        self.cursor = None
-        self.daemon = True
-
-    def _connect(self):
-        self.conn = sqlite3.connect(self.db_path)
-        self.cursor = self.conn.cursor()
-
-    def run(self):
-        self._connect()
-        while True:
-            try:
-                event = self.event_queue.get()
-                if event is None:  # Exit signal
-                    break
-                self._store_to_db(event)
-            except Exception as e:
-                logger.error(f"Error processing event: {e}")
-        self._close_connection()
-
-    def _store_to_db(self, event):
-        self.cursor.execute("""
-            INSERT INTO events (event_id, line_id, text, time)
-            VALUES (?, ?, ?, ?)
-        """, (event.id, event.line.id, event.text, event.time.isoformat()))
-        self.conn.commit()
-
-    def _close_connection(self):
-        if self.conn:
-            self.conn.close()
-
-
-# Global instances
-event_manager = EventManager()
-event_queue = queue.Queue()
-
-# Initialize the EventProcessor with the queue and event manager
-event_processor = EventProcessor(event_queue, DB_PATH)
-event_processor.start()
+        # Clear the in-memory events
+        self.events = [
+            event for event in self.events if not event.history]
+        self.events_dict = {
+            event.id: event for event in self.events}
+        self.ids = {event.id for event in self.events}
+
+    def remove_lines_by_ids(self, ids: list[str], timed_out: bool = False):
+        ids_to_remove = set(ids)
+        
+        self.events = [event for event in self.events if event.id not in ids_to_remove]
+        
+        for event_id in ids_to_remove:
+            self.events_dict.pop(event_id, None)
+        
+        # Remove from set (much more efficient than rebuilding)
+        self.ids -= ids_to_remove
+        if timed_out:
+            self.timed_out_ids.update(ids_to_remove)
+
+
+# Global instance
+event_manager = EventManager()

GameSentenceMiner/web/templates/anki_stats.html

@@ -325,6 +325,7 @@
             </div>
         </div>
     </div>
+    {% include 'components/settings-modal.html' %}
 </div>
 
 <!-- Include shared JavaScript configuration -->