GameSentenceMiner 2.8.6__py3-none-any.whl → 2.8.8__py3-none-any.whl

GameSentenceMiner/web/{static → templates}/utility.html

@@ -59,6 +59,7 @@
         }
 
         .textline-buttons {
+            margin-left: auto; /* Align buttons to the right */
             display: flex;
             gap: 10px;
         }
@@ -109,7 +110,7 @@
 <div id="initial-events">
 
 </div>
-<hr class="initial-events-separator" style="display: none;">
+<hr class="initial-events-separator" id="initial-events-separator" style="display: none;">
 <div id="session-events">
 
 </div>
@@ -119,11 +120,14 @@
     </button>
 </div>
 <script>
+    let mainStyle = document.querySelector('head style');
+    console.log(mainStyle);
     let displayedEventIds = new Set();
     let isTabActive = true;
     let isFetching = false; // Flag to track if a fetch is in progress
     let intervalId = 0;
-    const fetchInterval = 100; // Define the interval as a constant
+    const fetchInterval = 5000; // Define the interval as a constant
+    const websocketPort = {{ websocket_port }} || 55001;
 
     // Drag selection variables
     let isDragging = false;
@@ -150,7 +154,12 @@
 
             events.forEach(ev => {
                 if (!displayedEventIds.has(ev.id)) {
-                    addNewEvent(ev)
+                    if (ev.history) {
+                        addNewEventToHistory(ev)
+                        document.getElementById('initial-events-separator').style.display = 'block';
+                    } else {
+                        addNewEvent(ev)
+                    }
                 }
                 const checkbox = document.querySelector(`[data-event-id="${ev.id}"]`);
                 if (checkbox && !checkboxes_being_updated.has(ev.id)) {
@@ -165,27 +174,68 @@
         }
     }
 
-    function addNewEvent(event) {
-        const container = document.getElementById('session-events');
+    function addNewEventToHistory(event) {
+        displayedEventIds.add(event.id);
+        const container = document.getElementById('initial-events');
         const div = document.createElement('div');
-        div.className = 'textline';
-        div.innerHTML = `
-                            <input type="checkbox"
-                            class="multi-line-checkbox"
-                            id="multi-line-checkbox-${event.id}"
-                            ${event.checked ? 'checked' : ''}
-                            aria-label="Mark item"
-                            data-event-id="${event.id}"
-                            onchange="toggleCheckbox('${event.id}', this.checked)">
-                            <p>${event.text}</p>
-                            <em>${event.time.replace(" GMT", "")}</em>
-                            <div class="textline-buttons">
-                                <button onclick="buttonClick('${event.id}', 'Screenshot')">Screenshot</button>
-                                <button onclick="buttonClick('${event.id}', 'Audio')">Audio</button>
-                            </div>
+        // div.className = 'textline';
+
+        const shadowRoot = div.attachShadow({ mode: 'open' });
+
+        const wrapper = document.createElement('div');
+        wrapper.className = 'textline';
+        wrapper.innerHTML = `<p>${event.text}</p>
+                             <em class="clock-icon">${event.time.replace(' GMT', '')}</em>
                         `;
+
+        const style = document.createElement('style');
+        style.textContent = mainStyle.innerHTML;
+        shadowRoot.appendChild(style);
+        shadowRoot.appendChild(wrapper);
+
         container.appendChild(div);
+        window.scrollTo({
+            top: document.documentElement.scrollHeight,
+            behavior: 'smooth'
+        });
+    }
+
+    function addNewEvent(event) {
         displayedEventIds.add(event.id);
+        const container = document.getElementById('session-events');
+        const div = document.createElement('div');
+        // div.className = 'textline';
+
+        const shadowRoot = div.attachShadow({ mode: 'open' }); // 'open' allows access from the main DOM
+
+        const wrapper = document.createElement('div');
+        wrapper.className = 'textline';
+        wrapper.innerHTML = `
+        <input type="checkbox"
+        class="multi-line-checkbox"
+        id="multi-line-checkbox-${event.id}"
+        ${event.checked ? 'checked' : ''}
+        aria-label="Mark item"
+        data-event-id="${event.id}"
+        onchange="toggleCheckbox('${event.id}', this.checked)">
+        <p>${event.text}</p>
+        <div class="textline-buttons">
+            <button onclick="buttonClick('${event.id}', 'Screenshot')" title="Screenshot" style="background-color: #333; color: #fff; border: 1px solid #555; padding: 6px 10px; font-size: 10px; border-radius: 4px; cursor: pointer; transition: background-color 0.3s;">
+                &#x1F4F7;
+            </button>
+            <button onclick="buttonClick('${event.id}', 'Audio')" title="Audio" style="background-color: #333; color: #fff; border: 1px solid #555; padding: 6px 10px; font-size: 10px; border-radius: 4px; cursor: pointer; transition: background-color 0.3s;">
+                &#x1F50A;
+            </button>
+        </div>
+    `;
+
+        // Apply your component's styles within the shadow DOM
+        const style = document.createElement('style');
+        style.textContent = mainStyle.innerHTML;
+        shadowRoot.appendChild(style);
+        shadowRoot.appendChild(wrapper);
+
+        container.appendChild(div);
         window.scrollTo({
             top: document.documentElement.scrollHeight,
             behavior: 'smooth'
@@ -299,6 +349,66 @@
     document.addEventListener('mouseover', handleMouseOver);
     document.addEventListener('click', handleCheckboxClick);
 
+    const websocketURL = 'ws://localhost:' + websocketPort;
+    let websocket = {};
+    let reconnectInterval = 1000; // Time in milliseconds to wait before attempting to reconnect
+
+    const connectWebSocket = () => {
+        if (websocket && websocket.readyState === WebSocket.OPEN) {
+            console.log('WebSocket already open, no need to reconnect.');
+            return;
+        }
+        if (websocket && websocket.readyState === WebSocket.CONNECTING) {
+            console.log('WebSocket is currently connecting, waiting...');
+            return;
+        }
+
+        websocket = new WebSocket(websocketURL);
+
+        websocket.onopen = (event) => {
+            console.log('WebSocket connection opened');
+            websocket.send(JSON.stringify({ type: 'initial_data_request' }));
+        };
+
+        websocket.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            console.log('Received message:', data);
+            if (data.event === 'text_received') {
+                console.log("Adding new event:", data.data);
+                addNewEvent(data.data);
+            } else {
+                console.log('Other message:', data);
+            }
+        };
+
+        websocket.onclose = (event) => {
+            console.log(`WebSocket connection closed. Attempting to reconnect in ${reconnectInterval / 1000} seconds...`);
+            // Only attempt to reconnect if the current websocket object is the one that closed
+            if (websocket === event.target) {
+                // Clear the current websocket reference to allow for a new connection
+                websocket = null;
+                setTimeout(connectWebSocket, reconnectInterval);
+            }
+        };
+
+        websocket.onerror = (error) => {
+            console.error('WebSocket error:', error);
+            // Optionally attempt to reconnect on error as well, ensuring we don't have an active connection
+            if (websocket === error.target || websocket === null) {
+                console.log(`Attempting to reconnect in ${reconnectInterval / 1000} seconds...`);
+                // Clear the current websocket reference
+                websocket = null;
+                setTimeout(connectWebSocket, reconnectInterval);
+            }
+        };
+        return websocket;
+    };
+
+    connectWebSocket();
+
+
+    fetchEvents();
+
     console.log("Initial load, fetching events and starting interval...");
     fetchEvents();
     intervalId = setInterval(async () => {

GameSentenceMiner/web/texthooking_page.py

@@ -1,19 +1,25 @@
+import asyncio
 import datetime
 import json
 import os
+import queue
+import sqlite3
+import threading
 from dataclasses import dataclass
 
 import flask
+import websockets
 
-from GameSentenceMiner.text_log import GameLine, get_line_by_id
+from GameSentenceMiner.text_log import GameLine, get_line_by_id, initial_time
 from flask import request, jsonify, send_from_directory
 import webbrowser
 from GameSentenceMiner import obs
-from GameSentenceMiner.configuration import logger, get_config
+from GameSentenceMiner.configuration import logger, get_config, DB_PATH
 from GameSentenceMiner.util import TEXT_REPLACEMENTS_FILE
 
 port = get_config().general.texthooker_port
 url = f"http://localhost:{port}"
+websocket_port = 55001
 
 
 @dataclass
@@ -22,16 +28,25 @@ class EventItem:
     id: str
     text: str
     time: datetime.datetime
-    timestamp: float
     checked: bool = False
+    history: bool = False
 
     def to_dict(self):
         return {
             'id': self.id,
             'text': self.text,
             'time': self.time,
-            'timestamp': self.timestamp,
-            'checked': self.checked
+            '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:
@@ -43,6 +58,36 @@ class EventManager:
     def __init__(self):
         self.events = []
         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.events_dict[event_id] = event
 
     def __iter__(self):
         return iter(self.events)
@@ -51,20 +96,69 @@ class EventManager:
         self.events = new_events
 
     def add_gameline(self, line: GameLine):
-        new_event = EventItem(line, line.id, line.text, line.time, line.time.timestamp(), False)
+        new_event = EventItem(line, line.id, line.text, line.time, False, False)
         self.events_dict[line.id] = new_event
         self.events.append(new_event)
+        # self.store_to_db(new_event)
+        event_queue.put(new_event)
+        return new_event
 
     def get_events(self):
         return self.events
 
     def add_event(self, event):
         self.events.append(event)
+        event_queue.put(event)
 
     def get(self, event_id):
         return self.events_dict.get(event_id)
 
+    def close_connection(self):
+        if self.conn:
+            self.conn.close()
+
+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()
 
@@ -119,27 +213,28 @@ def serve_static(filename):
 
 @app.route('/')
 def index():
-    with open(os.path.join(app.root_path, 'static', 'utility.html'), encoding='utf-8') as file:
-        return file.read()
+    return flask.render_template('utility.html', websocket_port=websocket_port)
 
 @app.route('/texthooker')
 def texthooker():
-    with open(os.path.join(app.root_path, 'static', 'utility.html'), encoding='utf-8') as file:
-        return file.read()
+    return flask.render_template('utility.html', websocket_port=websocket_port)
 
 @app.route('/textreplacements')
 def textreplacements():
-    with open(os.path.join(app.root_path, 'static', 'text_replacements.html'), encoding='utf-8') as file:
-        return file.read()
+    return flask.render_template('text_replacements.html')
 
 @app.route('/data', methods=['GET'])
 def get_data():
     return jsonify([event.to_dict() for event in event_manager])
 
 
-def add_event_to_texthooker(line: GameLine):
+async def add_event_to_texthooker(line: GameLine):
     logger.info("Adding event to web server: %s", line.text)
-    event_manager.add_gameline(line)
+    new_event = event_manager.add_gameline(line)
+    await broadcast_message({
+        'event': 'text_received',
+        'data': new_event.to_serializable()
+    })
 
 
 @app.route('/update', methods=['POST'])
@@ -178,6 +273,42 @@ def play_audio():
     return jsonify({}), 200
 
 
+connected_clients = set()
+
+async def websocket_handler(websocket):
+    logger.debug(f"Client connected: {websocket.remote_address}")
+    connected_clients.add(websocket)
+    try:
+        async for message in websocket:
+            try:
+                data = json.loads(message)
+                if 'type' in data and data['type'] == 'get_events':
+                    initial_events = [{'id': 1, 'text': 'Initial event from WebSocket'}, {'id': 2, 'text': 'Another initial event'}]
+                    await websocket.send(json.dumps({'event': 'initial_events', 'payload': initial_events}))
+                elif 'update_checkbox' in data:
+                    print(f"Received checkbox update: {data}")
+                    # Handle checkbox update logic
+                    pass
+                await websocket.send(json.dumps({'response': f'Server received: {message}'}))
+            except json.JSONDecodeError:
+                await websocket.send(json.dumps({'error': 'Invalid JSON format'}))
+    except websockets.exceptions.ConnectionClosedError:
+        print(f"Client disconnected abruptly: {websocket.remote_address}")
+    except websockets.exceptions.ConnectionClosedOK:
+        print(f"Client disconnected gracefully: {websocket.remote_address}")
+    finally:
+        connected_clients.discard(websocket)
+
+async def broadcast_message(message):
+    if connected_clients:
+        tasks = [client.send(json.dumps(message)) for client in connected_clients]
+        await asyncio.gather(*tasks)
+
+# 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()
@@ -225,5 +356,31 @@ def start_web_server():
 
     app.run(port=port, debug=False) # debug=True provides helpful error messages during development
 
+async def run_websocket_server(host="0.0.0.0", port=55001):
+    global websocket_port
+    while True:
+        websocket_port = port
+        try:
+            async with websockets.serve(websocket_handler, host, port):
+                logger.debug(f"WebSocket server started at ws://{host}:{port}/")
+                await asyncio.Future()  # Keep the WebSocket server running
+        except OSError as e:
+            logger.debug(f"Port {port} is in use. Trying the next port...")
+            port += 1
+
+
+
+async def texthooker_page_coro():
+    # Run the WebSocket server in the asyncio event loop
+    flask_thread = threading.Thread(target=start_web_server)
+    flask_thread.daemon = True
+    flask_thread.start()
+
+    # Keep the main asyncio event loop running (for the WebSocket server)
+    await run_websocket_server()
+
+def run_text_hooker_page():
+    asyncio.run(texthooker_page_coro())
+
 if __name__ == '__main__':
-    start_web_server()
+    asyncio.run(run_text_hooker_page())

{gamesentenceminer-2.8.6.dist-info → gamesentenceminer-2.8.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.8.6
+Version: 2.8.8
 Summary: A tool for mining sentences from games. Update: Multi-Line Mining! Fixed!
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
@@ -36,6 +36,7 @@ Requires-Dist: pywin32; sys_platform == "win32"
 Requires-Dist: google-generativeai
 Requires-Dist: pygetwindow; sys_platform == "win32"
 Requires-Dist: flask
+Requires-Dist: groq
 Dynamic: license-file
 
 # Game Sentence Miner

{gamesentenceminer-2.8.6.dist-info → gamesentenceminer-2.8.8.dist-info}/RECORD

@@ -1,19 +1,19 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/anki.py,sha256=2Oy3a8Od8DC3vs1-ktS6KF1iUj74Ptd0SCe-U0cZcfc,14206
-GameSentenceMiner/config_gui.py,sha256=8Wc5YdAyaYT09T4pvHiL5Q4NiKRaL19CS3A0JhnSu6k,68822
-GameSentenceMiner/configuration.py,sha256=NQMsM23p4_keTFXEaKMTMacIx0TCdk4-TIl4usZkJy4,20801
+GameSentenceMiner/anki.py,sha256=pSkf-il17vKZIBt1ZHHDMfvfO9M-GdF1zox-c--KkAY,14208
+GameSentenceMiner/config_gui.py,sha256=mOsk_9rqQ09VUdUNuSMx-gHTAS2o41T3kD7qpYq3TJA,70928
+GameSentenceMiner/configuration.py,sha256=nV2FLrT-XbedPakHDKo8TddtnWj9Q2RCPFGcVs_S4RY,21673
 GameSentenceMiner/electron_config.py,sha256=dGcPYCISPehXubYSzsDuI2Gl092MYK0u3bTnkL9Jh1Y,9787
 GameSentenceMiner/ffmpeg.py,sha256=mcEcJnYl06oJGbLaymFUfqClFiHf6Hhf2SXo3UV9tvM,13378
-GameSentenceMiner/gametext.py,sha256=pPJO-NYW15SqAG-IQ0ZHpPt8py4g0yL1Lx0UlR-en-4,5431
-GameSentenceMiner/gsm.py,sha256=6BcCYNV9tGQ8FgDh6Y8bPbZ66KWP57oBUqIoVF_nnXg,24667
+GameSentenceMiner/gametext.py,sha256=ClSpOeohBWG17MRVIbhXfNDnkUdxU9mTspGv9975uEc,5422
+GameSentenceMiner/gsm.py,sha256=vCEPg7rE68AUD2u6DesjLxuZSy1gJzbiA0fig673WRM,25254
 GameSentenceMiner/model.py,sha256=JdnkT4VoPOXmOpRgFdvERZ09c9wLN6tUJxdrKlGZcqo,5305
 GameSentenceMiner/notification.py,sha256=FY39ChSRK0Y8TQ6lBGsLnpZUFPtFpSy2tweeXVoV7kc,2809
-GameSentenceMiner/obs.py,sha256=DLTcK48Dqcg-5BYC2Fp-tPCO4dVI9FuVYbwIawECkwQ,8977
+GameSentenceMiner/obs.py,sha256=GPlsFrcv1eYelXyJfpspGK0iZK5AXPkoFsIGdB7eJrk,10002
 GameSentenceMiner/package.py,sha256=YlS6QRMuVlm6mdXx0rlXv9_3erTGS21jaP3PNNWfAH0,1250
 GameSentenceMiner/text_log.py,sha256=tBuZ8ElUgPtiQV8U6U90kmRxposwIkL3fjOYejdzikc,5153
 GameSentenceMiner/util.py,sha256=bb75EQdk4Nf0i9t3XMznjd6NxTWfkOVeE5bZFstbCbU,8910
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/ai/gemini.py,sha256=6kTQPuRH16D-1srhrWa5uPGIy-jBqNm9eRdKBSbpiXA,5423
+GameSentenceMiner/ai/ai_prompting.py,sha256=tu7MxItzuJ5iSyieWIt1YHrMDEUKYAAlur6WWLZ61D4,9137
 GameSentenceMiner/communication/__init__.py,sha256=_jGn9PJxtOAOPtJ2rI-Qu9hEHVZVpIvWlxKvqk91_zI,638
 GameSentenceMiner/communication/send.py,sha256=oOJdCS6-LNX90amkRn5FL2xqx6THGm56zHR2ntVIFTE,229
 GameSentenceMiner/communication/websocket.py,sha256=pTcUe_ZZRp9REdSU4qalhPmbT_1DKa7w18j6RfFLELA,3074
@@ -24,21 +24,21 @@ GameSentenceMiner/downloader/oneocr_dl.py,sha256=o3ANp5IodEQoQ8GPcJdg9Y8JzA_lict
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=zagsB4UD9mmZX_r6dFBCXZqdDa0XGk-RvIqbKoPB9lQ,1932
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
-GameSentenceMiner/ocr/owocr_area_selector.py,sha256=a2i4kW9g9_DJKt6OJ5dlSiqJGiXkKyqAQaAiXBdrq8U,46680
-GameSentenceMiner/ocr/owocr_helper.py,sha256=J6FrcxikTbfoHnnvQfp5uvGIragASrB4I3oepBCcziE,16076
+GameSentenceMiner/ocr/owocr_area_selector.py,sha256=gwYOz-fA5qoL63wh77eyGJtBtO7YVvWyO5cHb3D0Oz4,46738
+GameSentenceMiner/ocr/owocr_helper.py,sha256=PCsPbqrECSbi4u8NIq3PJotStaYVBBbfccHu-DrqpwU,17269
 GameSentenceMiner/owocr/owocr/__init__.py,sha256=opjBOyGGyEqZCE6YdZPnyt7nVfiwyELHsXA0jAsjm14,25
 GameSentenceMiner/owocr/owocr/__main__.py,sha256=r8MI6RAmbkTWqOJ59uvXoDS7CSw5jX5war9ULGWELrA,128
-GameSentenceMiner/owocr/owocr/config.py,sha256=738QCJHEWpFhMh966plOcXYWwcshSiRsxjjIwldeTtI,7461
+GameSentenceMiner/owocr/owocr/config.py,sha256=n-xtVylb2Q_H84jb1ZsIGxPQjTNnyvnRny1RhtaLJM8,7550
 GameSentenceMiner/owocr/owocr/lens_betterproto.py,sha256=oNoISsPilVVRBBPVDtb4-roJtAhp8ZAuFTci3TGXtMc,39141
 GameSentenceMiner/owocr/owocr/ocr.py,sha256=n24Xg8Z8dbcgLpq1u4d22z3tLV1evmf0dK3-Xocv3vs,39878
-GameSentenceMiner/owocr/owocr/run.py,sha256=WP3YTocRnZh4AHysIgLokemcaowatMjwfxS0IcxIHps,47859
+GameSentenceMiner/owocr/owocr/run.py,sha256=fzRUo1iYDZffolYHffqCaIYpvBLO2r_FbXgoQ35Eiqk,51151
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=fjJ3CSXLti3WboGPpmsa7MWOwIXsfpHC8N4zKahGGY0,3346
 GameSentenceMiner/vad/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/vad/silero_trim.py,sha256=ULf3zwS-JMsY82cKF7gZxREHw8L6lgpWF2U1YqgE9Oc,1681
 GameSentenceMiner/vad/vosk_helper.py,sha256=125X8C9NxFPlWWpoNsbOnEqKx8RCjXN109zNx_QXhyg,6070
 GameSentenceMiner/vad/whisper_helper.py,sha256=JJ-iltCh813XdjyEw0Wn5DaErf6PDqfH0Efu1Md8cIY,3543
 GameSentenceMiner/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/web/texthooking_page.py,sha256=INCBzEUk0I_452OpDnfDMeGMaMCAJWSmq14S4V1ToHA,7227
+GameSentenceMiner/web/texthooking_page.py,sha256=bI1itAIY4iPjGlFTmtrLbcjo6pvvp_dFlSOYrEDWPJ0,12760
 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
@@ -46,13 +46,13 @@ GameSentenceMiner/web/static/favicon.ico,sha256=7d25r_FBqRSNsAoEHpSzNoT7zyVt2DJR
 GameSentenceMiner/web/static/favicon.svg,sha256=x305AP6WlXGtrXIZlaQspdLmwteoFYUoe5FyJ9MYlJ8,11517
 GameSentenceMiner/web/static/site.webmanifest,sha256=kaeNT-FjFt-T7JGzOhXH7YSqsrDeiplZ2kDxCN_CFU4,436
 GameSentenceMiner/web/static/style.css,sha256=bPZK0NVMuyRl5NNDuT7ZTzVLKlvSsdmeVHmAW4y5FM0,7001
-GameSentenceMiner/web/static/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
-GameSentenceMiner/web/static/utility.html,sha256=58br1whazdfrevWCHEzYNa1_VdBvebDDX2tWlX2QrFs,9964
 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-2.8.6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.8.6.dist-info/METADATA,sha256=-y0KqwQGu8y7OVhrpmzL0JSPusDvd4YtcxSip82DND4,5912
-gamesentenceminer-2.8.6.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-gamesentenceminer-2.8.6.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.8.6.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.8.6.dist-info/RECORD,,
+GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
+GameSentenceMiner/web/templates/utility.html,sha256=8yJvmHqkHoMN06qWDckhGoguWyP7LUVZ2oms0tBRdEw,14297
+gamesentenceminer-2.8.8.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.8.8.dist-info/METADATA,sha256=RPgmXLVp04j9a3UP9jNjqlcqpaSVdgzkGRuVRqy6ksg,5932
+gamesentenceminer-2.8.8.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+gamesentenceminer-2.8.8.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.8.8.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.8.8.dist-info/RECORD,,

{gamesentenceminer-2.8.6.dist-info → gamesentenceminer-2.8.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any