GameSentenceMiner 2.15.8__py3-none-any.whl → 2.15.10__py3-none-any.whl

GameSentenceMiner/web/texthooking_page.py

@@ -1,201 +1,52 @@
 import asyncio
-from ctypes.util import test
 import datetime
 import json
 import os
-import queue
-import sqlite3
 import threading
-from dataclasses import dataclass
 
 import flask
-import websockets
+import webbrowser
 
 from GameSentenceMiner.ai.ai_prompting import get_ai_prompt_result
 from GameSentenceMiner.obs import get_current_game
 from GameSentenceMiner.util.gsm_utils import TEXT_REPLACEMENTS_FILE
-from GameSentenceMiner.util.text_log import GameLine, get_line_by_id, initial_time, get_all_lines
-from flask import request, jsonify, send_from_directory
-import webbrowser
+from GameSentenceMiner.util.text_log import get_line_by_id, get_all_lines
+from flask import render_template, request, jsonify, send_from_directory
 from GameSentenceMiner import obs
-from GameSentenceMiner.util.configuration import logger, get_config, DB_PATH, gsm_state, gsm_status
+from GameSentenceMiner.util.configuration import logger, get_config, gsm_state, gsm_status
 from GameSentenceMiner.web.service import handle_texthooker_button
 
+# Import from new modules
+from GameSentenceMiner.web.events import (
+    EventItem, EventManager, EventProcessor, event_manager, event_queue, event_processor
+)
+from GameSentenceMiner.web.stats import (
+    is_kanji, interpolate_color, get_gradient_color, calculate_kanji_frequency,
+    calculate_heatmap_data, calculate_total_chars_per_game, calculate_reading_time_per_game,
+    calculate_reading_speed_per_game, generate_game_colors, format_large_number,
+    calculate_actual_reading_time, calculate_daily_reading_time, calculate_time_based_streak,
+    format_time_human_readable, calculate_current_game_stats, calculate_all_games_stats
+)
+from GameSentenceMiner.web.websockets import (
+    WebsocketServerThread, websocket_queue, paused, websocket_server_thread,
+    plaintext_websocket_server_thread, overlay_server_thread, websocket_server_threads,
+    handle_exit_signal
+)
+from GameSentenceMiner.web.database_api import register_database_api_routes
+
+# Global configuration
 port = get_config().general.texthooker_port
 url = f"http://localhost:{port}"
 websocket_port = 55001
 
-
-@dataclass
-class EventItem:
-    line: 'GameLine'
-    id: str
-    text: str
-    time: datetime.datetime
-    checked: bool = False
-    history: bool = False
-
-    def to_dict(self):
-        return {
-            'id': self.id,
-            'text': self.text,
-            'time': self.time,
-            'checked': self.checked,
-            'history': self.history,
-        }
-
-    def to_serializable(self):
-        return {
-            'id': self.id,
-            'text': self.text,
-            'time': self.time.isoformat(),
-            'checked': self.checked,
-            'history': self.history,
-        }
-
-
-class EventManager:
-    events: list[EventItem]
-    events_dict: dict[str, EventItem] = {}
-
-    def __init__(self):
-        self.events = []
-        self.ids = []
-        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
-
-    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.events.append(new_event)
-        # self.store_to_db(new_event)
-        # event_queue.put(new_event)
-        return new_event
-
-    def reset_checked_lines(self):
-        for event in self.events:
-            event.checked = False
-
-    def get_events(self):
-        return self.events
-
-    def add_event(self, event):
-        self.events.append(event)
-        self.ids.append(event.id)
-        event_queue.put(event)
-
-    def get(self, event_id):
-        return self.events_dict.get(event_id)
-
-    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()
-
-
-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()
-
 server_start_time = datetime.datetime.now().timestamp()
 
 app = flask.Flask(__name__)
 
-# Load data from the JSON file
-
+# Register database API routes
+register_database_api_routes(app)
 
+# Load data from the JSON file
 def load_data_from_file():
     if os.path.exists(TEXT_REPLACEMENTS_FILE):
         with open(TEXT_REPLACEMENTS_FILE, 'r', encoding='utf-8') as file:
@@ -203,8 +54,6 @@ def load_data_from_file():
     return {"enabled": True, "args": {"replacements": {}}}
 
 # Save data to the JSON file
-
-
 def save_data_to_file(data):
     with open(TEXT_REPLACEMENTS_FILE, 'w', encoding='utf-8') as file:
         json.dump(data, file, indent=4, ensure_ascii=False)
@@ -262,7 +111,19 @@ def texthooker():
 
 @app.route('/textreplacements')
 def textreplacements():
-    return flask.render_template('text_replacements.html')
+    # Serve the text replacements data as JSON for compatibility
+    try:
+        if not os.path.exists(TEXT_REPLACEMENTS_FILE):
+            return jsonify({"error": "Text replacements file not found."}), 404
+        with open(TEXT_REPLACEMENTS_FILE, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": f"Failed to load text replacements: {str(e)}"}), 500
+
+@app.route('/database')
+def database():
+    return flask.render_template('database.html')
 
 
 @app.route('/data', methods=['GET'])
@@ -283,7 +144,7 @@ def clear_history():
     return jsonify({'message': 'History cleared successfully'}), 200
 
 
-async def add_event_to_texthooker(line: GameLine):
+async def add_event_to_texthooker(line):
     new_event = event_manager.add_gameline(line)
     await websocket_server_thread.send_text({
         'event': 'text_received',
@@ -389,32 +250,24 @@ Translate the following lines of game dialogue into natural-sounding, context-aw
 def get_status():
     return jsonify(gsm_status.to_dict()), 200
 
+@app.template_filter('datetimeformat')
+def datetimeformat(value, format='%Y-%m-%d %H:%M:%S'):
+    """Formats a timestamp into a human-readable string."""
+    if value is None:
+        return ""
+    return datetime.datetime.fromtimestamp(float(value)).strftime(format)
+
 
-# async def main():
-#     async with websockets.serve(websocket_handler, "localhost", 8765): # Choose a port for WebSocket
-#         print("WebSocket server started on ws://localhost:8765/ws (adjust as needed)")
-#         await asyncio.Future()  # Keep the server running
-
-# @app.route('/store-events', methods=['POST'])
-# def store_events():
-#     data = request.get_json()
-#     events_data = data.get('events', [])
-#
-#     if not isinstance(events_data, list):
-#         return jsonify({'error': 'Invalid data format. Expected an array of events.'}), 400
-#
-#     for event_data in events_data:
-#         if not all(k in event_data for k in ('id', 'text', 'time', 'checked')):
-#              return jsonify({'error': 'Invalid event structure. Missing keys.'}), 400
-#         if not (isinstance(event_data['id'], (int, float)) and
-#                 isinstance(event_data['text'], str) and
-#                 isinstance(event_data['time'], str) and
-#                 isinstance(event_data['checked'], bool)):
-#             return jsonify({'error': 'Invalid event structure. Incorrect data types.'}), 400
-#
-#     event_manager.replace_events([EventItem(item['id'], item['text'], item['time'], item.get(['timestamp'], 0), item['checked']) for item in data])
-#
-#     return jsonify({'message': 'Events successfully stored on server.', 'receivedEvents': data}), 200
+@app.route('/stats')
+def stats():
+    """Renders the stats page."""
+    return render_template('stats.html')
+
+
+@app.route('/search')
+def search():
+    """Renders the search page."""
+    return render_template('search.html')
 
 
 def get_selected_lines():
@@ -452,117 +305,6 @@ def start_web_server():
     app.run(host='0.0.0.0', port=port, debug=False)
 
 
-websocket_queue = queue.Queue()
-paused = False
-
-
-class WebsocketServerThread(threading.Thread):
-    def __init__(self, read, get_ws_port_func):
-        super().__init__(daemon=True)
-        self._loop = None
-        self.read = read
-        self.clients = set()
-        self._event = threading.Event()
-        self.get_ws_port_func = get_ws_port_func
-        self.backedup_text = []
-
-    @property
-    def loop(self):
-        self._event.wait()
-        return self._loop
-
-    async def send_text_coroutine(self, message):
-        if not self.clients:
-            self.backedup_text.append(message)
-            return
-        for client in self.clients:
-            await client.send(message)
-
-    async def server_handler(self, websocket):
-        self.clients.add(websocket)
-        try:
-            if self.backedup_text:
-                for message in self.backedup_text:
-                    await websocket.send(message)
-                self.backedup_text.clear()
-            async for message in websocket:
-                if self.read and not paused:
-                    websocket_queue.put(message)
-                    try:
-                        await websocket.send('True')
-                    except websockets.exceptions.ConnectionClosedOK:
-                        pass
-                else:
-                    try:
-                        await websocket.send('False')
-                    except websockets.exceptions.ConnectionClosedOK:
-                        pass
-        except websockets.exceptions.ConnectionClosedError:
-            pass
-        finally:
-            self.clients.remove(websocket)
-
-    async def send_text(self, text):
-        if text:
-            if isinstance(text, dict) or isinstance(text, list):
-                text = json.dumps(text)
-            return asyncio.run_coroutine_threadsafe(
-                self.send_text_coroutine(text), self.loop)
-
-    def has_clients(self):
-        return len(self.clients) > 0
-
-    def stop_server(self):
-        self.loop.call_soon_threadsafe(self._stop_event.set)
-
-    def run(self):
-        async def main():
-            self._loop = asyncio.get_running_loop()
-            self._stop_event = stop_event = asyncio.Event()
-            self._event.set()
-            while True:
-                try:
-                    self.server = start_server = websockets.serve(self.server_handler,
-                                                                  "0.0.0.0",
-                                                                  self.get_ws_port_func(),
-                                                                  max_size=1000000000)
-                    async with start_server:
-                        await stop_event.wait()
-                    return
-                except Exception as e:
-                    logger.warning(
-                        f"WebSocket server encountered an error: {e}. Retrying...")
-                    await asyncio.sleep(1)
-
-        asyncio.run(main())
-
-
-def handle_exit_signal(loop):
-    logger.info("Received exit signal. Shutting down...")
-    for task in asyncio.all_tasks(loop):
-        task.cancel()
-
-
-websocket_server_thread = WebsocketServerThread(read=True, get_ws_port_func=lambda: get_config(
-).get_field_value('advanced', 'texthooker_communication_websocket_port'))
-websocket_server_thread.start()
-
-if get_config().advanced.plaintext_websocket_port:
-    plaintext_websocket_server_thread = WebsocketServerThread(
-        read=False, get_ws_port_func=lambda: get_config().get_field_value('advanced', 'plaintext_websocket_port'))
-    plaintext_websocket_server_thread.start()
-
-overlay_server_thread = WebsocketServerThread(
-    read=False, get_ws_port_func=lambda: get_config().get_field_value('overlay', 'websocket_port'))
-overlay_server_thread.start()
-
-websocket_server_threads = [
-    websocket_server_thread,
-    plaintext_websocket_server_thread,
-    overlay_server_thread
-]
-
-
 async def texthooker_page_coro():
     global websocket_server_thread, plaintext_websocket_server_thread, overlay_server_thread
     # Run the WebSocket server in the asyncio event loop
@@ -581,4 +323,4 @@ def run_text_hooker_page():
 
 
 if __name__ == '__main__':
-    asyncio.run(texthooker_page_coro())
+    asyncio.run(texthooker_page_coro())

GameSentenceMiner/web/websockets.py

@@ -0,0 +1,120 @@
+import asyncio
+import json
+import queue
+import threading
+import websockets
+
+from GameSentenceMiner.util.configuration import logger, get_config
+
+
+websocket_queue = queue.Queue()
+paused = False
+
+
+class WebsocketServerThread(threading.Thread):
+    def __init__(self, read, get_ws_port_func):
+        super().__init__(daemon=True)
+        self._loop = None
+        self.read = read
+        self.clients = set()
+        self._event = threading.Event()
+        self.get_ws_port_func = get_ws_port_func
+        self.backedup_text = []
+
+    @property
+    def loop(self):
+        self._event.wait()
+        return self._loop
+
+    async def send_text_coroutine(self, message):
+        if not self.clients:
+            self.backedup_text.append(message)
+            return
+        for client in self.clients:
+            await client.send(message)
+
+    async def server_handler(self, websocket):
+        self.clients.add(websocket)
+        try:
+            if self.backedup_text:
+                for message in self.backedup_text:
+                    await websocket.send(message)
+                self.backedup_text.clear()
+            async for message in websocket:
+                if self.read and not paused:
+                    websocket_queue.put(message)
+                    try:
+                        await websocket.send('True')
+                    except websockets.exceptions.ConnectionClosedOK:
+                        pass
+                else:
+                    try:
+                        await websocket.send('False')
+                    except websockets.exceptions.ConnectionClosedOK:
+                        pass
+        except websockets.exceptions.ConnectionClosedError:
+            pass
+        finally:
+            self.clients.remove(websocket)
+
+    async def send_text(self, text):
+        if text:
+            if isinstance(text, dict) or isinstance(text, list):
+                text = json.dumps(text)
+            return asyncio.run_coroutine_threadsafe(
+                self.send_text_coroutine(text), self.loop)
+
+    def has_clients(self):
+        return len(self.clients) > 0
+
+    def stop_server(self):
+        self.loop.call_soon_threadsafe(self._stop_event.set)
+
+    def run(self):
+        async def main():
+            self._loop = asyncio.get_running_loop()
+            self._stop_event = stop_event = asyncio.Event()
+            self._event.set()
+            while True:
+                try:
+                    self.server = start_server = websockets.serve(self.server_handler,
+                                                                  "0.0.0.0",
+                                                                  self.get_ws_port_func(),
+                                                                  max_size=1000000000)
+                    async with start_server:
+                        await stop_event.wait()
+                    return
+                except Exception as e:
+                    logger.warning(
+                        f"WebSocket server encountered an error: {e}. Retrying...")
+                    await asyncio.sleep(1)
+
+        asyncio.run(main())
+
+
+def handle_exit_signal(loop):
+    logger.info("Received exit signal. Shutting down...")
+    for task in asyncio.all_tasks(loop):
+        task.cancel()
+
+
+# Initialize WebSocket server threads
+websocket_server_thread = WebsocketServerThread(read=True, get_ws_port_func=lambda: get_config(
+).get_field_value('advanced', 'texthooker_communication_websocket_port'))
+websocket_server_thread.start()
+
+plaintext_websocket_server_thread = None
+if get_config().advanced.plaintext_websocket_port:
+    plaintext_websocket_server_thread = WebsocketServerThread(
+        read=False, get_ws_port_func=lambda: get_config().get_field_value('advanced', 'plaintext_websocket_port'))
+    plaintext_websocket_server_thread.start()
+
+overlay_server_thread = WebsocketServerThread(
+    read=False, get_ws_port_func=lambda: get_config().get_field_value('overlay', 'websocket_port'))
+overlay_server_thread.start()
+
+websocket_server_threads = [
+    websocket_server_thread,
+    plaintext_websocket_server_thread,
+    overlay_server_thread
+]

{gamesentenceminer-2.15.8.dist-info → gamesentenceminer-2.15.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.15.8
+Version: 2.15.10
 Summary: A tool for mining sentences from games. Update: Overlay?
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.15.8.dist-info → gamesentenceminer-2.15.10.dist-info}/RECORD

@@ -4,7 +4,7 @@ GameSentenceMiner/config_gui.py,sha256=i79PrY2pP8_VKvIL7uoDv5cgHvCCQBIe0mS_YnX2A
 GameSentenceMiner/gametext.py,sha256=fgBgLchezpauWELE9Y5G3kVCLfAneD0X4lJFoI3FYbs,10351
 GameSentenceMiner/gsm.py,sha256=t2GAhMwVEHUzCdqM4tIgAzBUvNmt_Gec515iePacD6k,31945
 GameSentenceMiner/obs.py,sha256=EyAYhaLvMjoeC-3j7fuvkqZN5logFFanPfb8Wn1C6m0,27296
-GameSentenceMiner/vad.py,sha256=BqwvKF0lRB_ys1On_Ua1vvimUFmkHO-D9gBbCkaBaxc,20193
+GameSentenceMiner/vad.py,sha256=N-urlVOT6ayk4BFuIeZhxK1VxLD4Flxu-IStuy8FAVc,20190
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/ai_prompting.py,sha256=41xdBzE88Jlt12A0D-T_cMfLO5j6MSxfniOptpwNZm0,24068
 GameSentenceMiner/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -19,17 +19,17 @@ GameSentenceMiner/locales/en_us.json,sha256=4lCV34FnDOe0c02qHlHnfujQedmqHSL-feN3
 GameSentenceMiner/locales/ja_jp.json,sha256=LNLo2qIugMcDGiPbSo018zVAU8K_HG8Q4zvIcsHUzTA,28517
 GameSentenceMiner/locales/zh_cn.json,sha256=lZYB3HAcxhVCSVWcnvuepuCvn6_Y2mvd0-SKJEYx_ko,24829
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=DfcR3bHTu26JJerLzqfW_KpdgUBSrRV4hqSy_LYclps,5967
+GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=Ov04c-nKzh3sADxO-5JyZWVe4DlrHM9edM9tc7-97Jo,5970
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
 GameSentenceMiner/ocr/owocr_area_selector.py,sha256=Rm1_nuZotJhfOfoJ_3mesh9udtOBjYqKhnAvSief6fo,29181
-GameSentenceMiner/ocr/owocr_helper.py,sha256=v1xIfKUwKZNEUUvFNzzalTmIl_Qj_ygFEX4AJszcAVA,31290
+GameSentenceMiner/ocr/owocr_helper.py,sha256=LoGKfVd1PL8R9UgOA_S1TiKT1i_b3Yb8quWl5ls1MEI,31689
 GameSentenceMiner/ocr/ss_picker.py,sha256=0IhxUdaKruFpZyBL-8SpxWg7bPrlGpy3lhTcMMZ5rwo,5224
 GameSentenceMiner/owocr/owocr/__init__.py,sha256=87hfN5u_PbL_onLfMACbc0F5j4KyIK9lKnRCj6oZgR0,49
 GameSentenceMiner/owocr/owocr/__main__.py,sha256=XQaqZY99EKoCpU-gWQjNbTs7Kg17HvBVE7JY8LqIE0o,157
 GameSentenceMiner/owocr/owocr/config.py,sha256=qM7kISHdUhuygGXOxmgU6Ef2nwBShrZtdqu4InDCViE,8103
 GameSentenceMiner/owocr/owocr/lens_betterproto.py,sha256=oNoISsPilVVRBBPVDtb4-roJtAhp8ZAuFTci3TGXtMc,39141
 GameSentenceMiner/owocr/owocr/ocr.py,sha256=vRTMKLzi6GDBFZWCyf0tYi6es3cP1cvQOBjZqaZmnBg,70482
-GameSentenceMiner/owocr/owocr/run.py,sha256=ctzAhX8nwTYy7E-tqiYFHK51XfY8Y_ze7rBHbDkVPqI,81240
+GameSentenceMiner/owocr/owocr/run.py,sha256=9Z_gIMCZkP5AGY6Lqz3QamSc6YOa5PeweXz9f4o8Msg,81222
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSdbN3QhEswtKuU1JjReFk_K8t5ezQE,3395
 GameSentenceMiner/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/tools/audio_offset_selector.py,sha256=8Stk3BP-XVIuzRv9nl9Eqd2D-1yD3JrgU-CamBywJmY,8542
@@ -37,7 +37,7 @@ GameSentenceMiner/tools/furigana_filter_preview.py,sha256=BXv7FChPEJW_VeG5XYt6su
 GameSentenceMiner/tools/ss_selector.py,sha256=cbjMxiKOCuOfbRvLR_PCRlykBrGtm1LXd6u5czPqkmc,4793
 GameSentenceMiner/tools/window_transparency.py,sha256=GtbxbmZg0-UYPXhfHff-7IKZyY2DKe4B9GdyovfmpeM,8166
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/util/configuration.py,sha256=cpgusOu4lItCBsZyB8QoAJaXjDovIXNlqyKzh2GMYzw,40241
+GameSentenceMiner/util/configuration.py,sha256=0S8rf_TTy7qbUZc7PLUXEZVScx27tV0cDZR_GcM1QKk,40412
 GameSentenceMiner/util/db.py,sha256=2bO0rD4i8A1hhsRBER-wgZy9IK17ibRbI8DHxdKvYsI,16598
 GameSentenceMiner/util/electron_config.py,sha256=KfeJToeFFVw0IR5MKa-gBzpzaGrU-lyJbR9z-sDEHYU,8767
 GameSentenceMiner/util/ffmpeg.py,sha256=jA-cFtCmdCWrUSPpdtFSLr-GSoqs4qNUzW20v4HPHf0,28715
@@ -45,7 +45,7 @@ GameSentenceMiner/util/get_overlay_coords.py,sha256=P5tI7H0cnveGs33aQdvJGy9DV6aI
 GameSentenceMiner/util/gsm_utils.py,sha256=Piwv88Q9av2LBeN7M6QDi0Mp0_R2lNbkcI6ekK5hd2o,11851
 GameSentenceMiner/util/model.py,sha256=R-_RYTYLSDNgBoVTPuPBcIHeOznIqi_vBzQ7VQ20WYk,6727
 GameSentenceMiner/util/notification.py,sha256=YBhf_mSo_i3cjBz-pmeTPx3wchKiG9BK2VBdZSa2prQ,4597
-GameSentenceMiner/util/text_log.py,sha256=zB9--7J_Wwck74IOEI4aWhmCYouqjSE6Sm0sCznF63Q,6731
+GameSentenceMiner/util/text_log.py,sha256=eqLchRrRsWeuex13f5IoxENLWMhjfZtJgUnh9N5jnJQ,6782
 GameSentenceMiner/util/communication/__init__.py,sha256=xh__yn2MhzXi9eLi89PeZWlJPn-cbBSjskhi1BRraXg,643
 GameSentenceMiner/util/communication/send.py,sha256=Wki9qIY2CgYnuHbmnyKVIYkcKAN_oYS4up93XMikBaI,222
 GameSentenceMiner/util/communication/websocket.py,sha256=Zpnqsy8RUeYxMFNGVUaPrWrlbAHjuNxCsn908iWL_kU,3344
@@ -56,8 +56,12 @@ GameSentenceMiner/util/downloader/oneocr_dl.py,sha256=l3s9Z-x1b57GX048o5h-MVv0UT
 GameSentenceMiner/util/win10toast/__init__.py,sha256=6TL2w6rzNmpJEp6_v2cAJP_7ExA3UsKzwdM08pNcVfE,5341
 GameSentenceMiner/util/win10toast/__main__.py,sha256=5MYnBcFj8y_6Dyc1kiPd0_FsUuh4yl1cv5wsleU6V4w,668
 GameSentenceMiner/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/web/database_api.py,sha256=kcyTWPuw_qtrK5qBzCFTIP0tqIvPmL-NEtiRL9BNbe8,35079
+GameSentenceMiner/web/events.py,sha256=6Vyz5c9MdpMIa7Zqljqhap2XFQnAVYJ0CdQV64TSZsA,5119
 GameSentenceMiner/web/service.py,sha256=YZchmScTn7AX_GkwV1ULEK6qjdOnJcpc3qfMwDf7cUE,5363
-GameSentenceMiner/web/texthooking_page.py,sha256=JhuApKUeQGwqGUO_92Z6yMY0_-kqHQceT4FGzhbGlGE,19269
+GameSentenceMiner/web/stats.py,sha256=daSSxWlumAyqVVtX10qHESF-tZYwCcFMp8qZA5AE0nI,22066
+GameSentenceMiner/web/texthooking_page.py,sha256=hkKu3SIi0V-wktiKhFhQEnhJe6PUWVZs_FSa1-wOYFQ,11134
+GameSentenceMiner/web/websockets.py,sha256=IwwQo6VtgPqeOuc-datgfJyLpX3LwB2MISDqA6EkiSA,4131
 GameSentenceMiner/web/static/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/web/static/apple-touch-icon.png,sha256=OcMI8af_68DA_tweOsQ5LytTyMwm7-hPW07IfrOVgEs,46132
 GameSentenceMiner/web/static/favicon-96x96.png,sha256=lOePzjiKl1JY2J1kT_PMdyEnrlJmi5GWbmXJunM12B4,16502
@@ -67,14 +71,16 @@ GameSentenceMiner/web/static/site.webmanifest,sha256=kaeNT-FjFt-T7JGzOhXH7YSqsrD
 GameSentenceMiner/web/static/style.css,sha256=bPZK0NVMuyRl5NNDuT7ZTzVLKlvSsdmeVHmAW4y5FM0,7001
 GameSentenceMiner/web/static/web-app-manifest-192x192.png,sha256=EfSNnBmsSaLfESbkGfYwbKzcjKOdzuWo18ABADfN974,51117
 GameSentenceMiner/web/static/web-app-manifest-512x512.png,sha256=wyqgCWCrLEUxSRXmaA3iJEESd-vM-ZmlTtZFBY4V8Pk,230819
-GameSentenceMiner/web/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/web/templates/database.html,sha256=iEJWQvvH_RGWmHuFx0iwNeamBV5FoVxZgFKgfm-4zc4,13582
 GameSentenceMiner/web/templates/index.html,sha256=LqXZx7-NE42pXSpHNZ3To680rD-vt9wEJoFYBlgp1qU,216923
-GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
-GameSentenceMiner/web/templates/utility.html,sha256=3flZinKNqUJ7pvrZk6xu__v67z44rXnaK7UTZ303R-8,16946
+GameSentenceMiner/web/templates/search.html,sha256=Fat3hOjQwkYBbdFhgWzRzZ5iEB78-2_0LpT7uK2aURE,3701
+GameSentenceMiner/web/templates/stats.html,sha256=I-3eb2521r7fvDHfCktOB79fhWj2_2lcjFJi9qWAbgA,16668
+GameSentenceMiner/web/templates/text_replacements.html,sha256=rB6mUvzzdbAlNV0dEukZlec0sXgRarBZw8Qh_eWRErE,16694
+GameSentenceMiner/web/templates/utility.html,sha256=KtqnZUMAYs5XsEdC9Tlsd40NKAVic0mu6sh-ReMDJpU,16940
 GameSentenceMiner/wip/__init___.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gamesentenceminer-2.15.8.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.15.8.dist-info/METADATA,sha256=bXBIX71jQ-PLrLVxpjrANJmu_ET8bA0EjRbgbgBl-AM,7348
-gamesentenceminer-2.15.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.15.8.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.15.8.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.15.8.dist-info/RECORD,,
+gamesentenceminer-2.15.10.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.15.10.dist-info/METADATA,sha256=T-Ik7ri7Xjt4D_J-Yd3fOVK0yf_rOrIe-oChyHlgOA8,7349
+gamesentenceminer-2.15.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.15.10.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.15.10.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.15.10.dist-info/RECORD,,