GameSentenceMiner 2.15.2__py3-none-any.whl → 2.15.4__py3-none-any.whl

GameSentenceMiner/config_gui.py

@@ -379,6 +379,7 @@ class ConfigApp:
         self.ai_enabled_value = tk.BooleanVar(value=self.settings.ai.enabled)
         self.ai_provider_value = tk.StringVar(value=self.settings.ai.provider)
         self.gemini_model_value = tk.StringVar(value=self.settings.ai.gemini_model)
+        self.use_cpu_for_inference_value = tk.BooleanVar(value=self.settings.vad.use_cpu_for_inference)
         self.groq_model_value = tk.StringVar(value=self.settings.ai.groq_model)
         self.gemini_api_key_value = tk.StringVar(value=self.settings.ai.gemini_api_key)
         self.groq_api_key_value = tk.StringVar(value=self.settings.ai.groq_api_key)
@@ -592,6 +593,7 @@ class ConfigApp:
                 language=self.language_value.get(),
                 cut_and_splice_segments=self.cut_and_splice_segments_value.get(),
                 splice_padding=float(self.splice_padding_value.get()) if self.splice_padding_value.get() else 0.0,
+                use_cpu_for_inference=self.use_cpu_for_inference_value.get(),
             ),
             advanced=Advanced(
                 audio_player_path=self.audio_player_path_value.get(),
@@ -1137,12 +1139,11 @@ class ConfigApp:
         ttk.Entry(vad_frame, textvariable=self.splice_padding_value).grid(row=self.current_row, column=3, sticky='EW', pady=2)
         self.current_row += 1
 
-        self.add_reset_button(vad_frame, "vad", self.current_row, 0, self.create_vad_tab)
-
-        for col in range(5): vad_frame.grid_columnconfigure(col, weight=0)
-        for row in range(self.current_row): vad_frame.grid_rowconfigure(row, minsize=30)
-
-        return vad_frame
+        # Force CPU for Whisper
+        use_cpu_i18n = vad_i18n.get('use_cpu_for_inference', {})
+        HoverInfoLabelWidget(vad_frame, text=use_cpu_i18n.get('label', 'Force CPU'), tooltip=use_cpu_i18n.get('tooltip', 'Even if CUDA is installed, use CPU for Whisper'), row=self.current_row, column=0)
+        ttk.Checkbutton(vad_frame, variable=self.use_cpu_for_inference_value, bootstyle="round-toggle").grid(row=self.current_row, column=1, sticky='W', pady=2)
+        self.current_row += 1
 
     @new_tab
     def create_paths_tab(self):
@@ -1224,8 +1225,10 @@ class ConfigApp:
 
         self.add_reset_button(paths_frame, "paths", self.current_row, 0, self.create_paths_tab)
 
-        for col in range(3): paths_frame.grid_columnconfigure(col, weight=0)
-        for row in range(self.current_row): paths_frame.grid_rowconfigure(row, minsize=30)
+        for col in range(3):
+            paths_frame.grid_columnconfigure(col, weight=0)
+        for row in range(self.current_row):
+            paths_frame.grid_rowconfigure(row, minsize=30)
 
         return paths_frame
 
@@ -1368,8 +1371,10 @@ class ConfigApp:
 
         self.add_reset_button(anki_frame, "anki", self.current_row, 0, self.create_anki_tab)
 
-        for col in range(2): anki_frame.grid_columnconfigure(col, weight=0)
-        for row in range(self.current_row): anki_frame.grid_rowconfigure(row, minsize=30)
+        for col in range(2):
+            anki_frame.grid_columnconfigure(col, weight=0)
+        for row in range(self.current_row):
+            anki_frame.grid_rowconfigure(row, minsize=30)
 
         return anki_frame
 
@@ -1431,8 +1436,10 @@ class ConfigApp:
 
         self.add_reset_button(features_frame, "features", self.current_row, 0, self.create_features_tab)
 
-        for col in range(3): features_frame.grid_columnconfigure(col, weight=0)
-        for row in range(self.current_row): features_frame.grid_rowconfigure(row, minsize=30)
+        for col in range(3):
+            features_frame.grid_columnconfigure(col, weight=0)
+        for row in range(self.current_row):
+            features_frame.grid_rowconfigure(row, minsize=30)
 
         return features_frame
 
@@ -1533,8 +1540,10 @@ class ConfigApp:
 
         self.add_reset_button(screenshot_frame, "screenshot", self.current_row, 0, self.create_screenshot_tab)
 
-        for col in range(3): screenshot_frame.grid_columnconfigure(col, weight=0)
-        for row in range(self.current_row): screenshot_frame.grid_rowconfigure(row, minsize=30)
+        for col in range(3):
+            screenshot_frame.grid_columnconfigure(col, weight=0)
+        for row in range(self.current_row):
+            screenshot_frame.grid_rowconfigure(row, minsize=30)
 
         return screenshot_frame
 
@@ -1647,8 +1656,10 @@ class ConfigApp:
 
         self.add_reset_button(audio_frame, "audio", self.current_row, 0, self.create_audio_tab)
 
-        for col in range(5): audio_frame.grid_columnconfigure(col, weight=0)
-        for row in range(self.current_row): audio_frame.grid_rowconfigure(row, minsize=30)
+        for col in range(5):
+            audio_frame.grid_columnconfigure(col, weight=0)
+        for row in range(self.current_row):
+            audio_frame.grid_rowconfigure(row, minsize=30)
 
         return audio_frame
 
@@ -1752,8 +1763,10 @@ class ConfigApp:
 
         self.add_reset_button(obs_frame, "obs", self.current_row, 0, self.create_obs_tab)
 
-        for col in range(3): obs_frame.grid_columnconfigure(col, weight=0)
-        for row in range(self.current_row): obs_frame.grid_rowconfigure(row, minsize=30)
+        for col in range(3):
+            obs_frame.grid_columnconfigure(col, weight=0)
+        for row in range(self.current_row):
+            obs_frame.grid_rowconfigure(row, minsize=30)
 
         return obs_frame
 
@@ -1814,8 +1827,10 @@ class ConfigApp:
             row=self.current_row, column=1, sticky='W', pady=2)
         self.current_row += 1
 
-        for col in range(4): profiles_frame.grid_columnconfigure(col, weight=0)
-        for row in range(self.current_row): profiles_frame.grid_rowconfigure(row, minsize=30)
+        for col in range(4):
+            profiles_frame.grid_columnconfigure(col, weight=0)
+        for row in range(self.current_row):
+            profiles_frame.grid_rowconfigure(row, minsize=30)
 
         return profiles_frame
 
@@ -1945,8 +1960,10 @@ class ConfigApp:
 
         self.add_reset_button(advanced_frame, "advanced", self.current_row, 0, self.create_advanced_tab)
 
-        for col in range(4): advanced_frame.grid_columnconfigure(col, weight=0)
-        for row in range(self.current_row): advanced_frame.grid_rowconfigure(row, minsize=30)
+        for col in range(4):
+            advanced_frame.grid_columnconfigure(col, weight=0)
+        for row in range(self.current_row):
+            advanced_frame.grid_rowconfigure(row, minsize=30)
 
         return advanced_frame
 
@@ -1997,6 +2014,12 @@ class ConfigApp:
         self.groq_models_combobox = ttk.Combobox(ai_frame, textvariable=self.groq_model_value, values=RECOMMENDED_GROQ_MODELS, state="readonly")
         self.groq_models_combobox.grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
+
+        # Force CPU for Whisper
+        use_cpu_i18n = ai_i18n.get('use_cpu_for_inference', {})
+        HoverInfoLabelWidget(ai_frame, text=use_cpu_i18n.get('label', 'Force CPU'), tooltip=use_cpu_i18n.get('tooltip', 'Even if CUDA is installed, use CPU for Whisper'), row=self.current_row, column=0)
+        ttk.Checkbutton(ai_frame, variable=self.use_cpu_for_inference_value, bootstyle="round-toggle").grid(row=self.current_row, column=1, sticky='W', pady=2)
+        self.current_row += 1
                 
         groq_key_i18n = ai_i18n.get('groq_api_key', {})
         HoverInfoLabelWidget(ai_frame, text=groq_key_i18n.get('label', '...'), tooltip=groq_key_i18n.get('tooltip', '...'),
@@ -2067,8 +2090,10 @@ class ConfigApp:
 
         self.add_reset_button(ai_frame, "ai", self.current_row, 0, self.create_ai_tab)
 
-        for col in range(3): ai_frame.grid_columnconfigure(col, weight=0)
-        for row in range(self.current_row): ai_frame.grid_rowconfigure(row, minsize=30)
+        for col in range(3):
+            ai_frame.grid_columnconfigure(col, weight=0)
+        for row in range(self.current_row):
+            ai_frame.grid_rowconfigure(row, minsize=30)
 
         return ai_frame
     
@@ -2245,8 +2270,10 @@ class ConfigApp:
 
         self.add_reset_button(wip_frame, "wip", self.current_row, 0, self.create_wip_tab)
 
-        for col in range(2): wip_frame.grid_columnconfigure(col, weight=0)
-        for row in range(self.current_row): wip_frame.grid_rowconfigure(row, minsize=30)
+        for col in range(2):
+            wip_frame.grid_columnconfigure(col, weight=0)
+        for row in range(self.current_row):
+            wip_frame.grid_rowconfigure(row, minsize=30)
 
         return wip_frame
     

GameSentenceMiner/locales/en_us.json

@@ -260,6 +260,10 @@
           "splice_padding": {
             "label": "Padding:",
             "tooltip": "Cut Detected Voice Segments and Paste them back together. More Padding = More Space between voicelines."
+          },
+          "use_cpu_for_inference": {
+            "label": "Force CPU:",
+            "tooltip": "Even if CUDA is installed, use CPU for Whisper"
           }
         },
         "features": {

GameSentenceMiner/locales/ja_jp.json

@@ -259,6 +259,10 @@
           "splice_padding": {
             "label": "パディング:",
             "tooltip": "結合する音声セグメント間の間隔（秒）。"
+          },
+          "use_cpu_for_inference": {
+            "label": "CPU強制使用:",
+            "tooltip": "CUDAがインストールされていてもWhisperでCPUを使用します"
           }
         },
         "features": {

GameSentenceMiner/locales/zh_cn.json

@@ -260,6 +260,10 @@
           "splice_padding": {
             "label": "填充:",
             "tooltip": "剪切检测到的语音片段并将其重新拼接。更多填充 = 语音间距更大。"
+          },
+          "use_cpu_for_inference": {
+            "label": "强制使用 CPU:",
+            "tooltip": "即使已安装 CUDA，也强制使用 CPU 运行 Whisper"
           }
         },
         "features": {

GameSentenceMiner/obs.py

@@ -5,6 +5,7 @@ import subprocess
 import threading
 import time
 import logging
+import contextlib
 
 import psutil
 
@@ -16,7 +17,7 @@ from GameSentenceMiner.util.gsm_utils import sanitize_filename, make_unique_file
 import tkinter as tk
 from tkinter import messagebox
 
-client: obs.ReqClient = None
+connection_pool: 'OBSConnectionPool' = None
 event_client: obs.EventClient = None
 obs_process_pid = None
 OBS_PID_FILE = os.path.join(configuration.get_app_directory(), 'obs-studio', 'obs_pid.txt')
@@ -24,6 +25,81 @@ obs_connection_manager = None
 logging.getLogger("obsws_python").setLevel(logging.CRITICAL)
 connecting = False
 
+class OBSConnectionPool:
+    """Manages a pool of thread-safe connections to the OBS WebSocket."""
+    def __init__(self, size=3, **kwargs):
+        self.size = size
+        self.connection_kwargs = kwargs
+        self._clients = [None] * self.size
+        self._locks = [threading.Lock() for _ in range(self.size)]
+        self._next_idx = 0
+        self._idx_lock = threading.Lock()
+        logger.info(f"Initialized OBSConnectionPool with size {self.size}")
+
+    def connect_all(self):
+        """Initializes all client objects in the pool."""
+        for i in range(self.size):
+            try:
+                self._clients[i] = obs.ReqClient(**self.connection_kwargs)
+            except Exception as e:
+                logger.error(f"Failed to create client {i} in pool: {e}")
+        return True
+
+    def disconnect_all(self):
+        """Disconnects all clients in the pool."""
+        for client in self._clients:
+            if client:
+                try:
+                    client.disconnect()
+                except Exception:
+                    pass
+        self._clients = [None] * self.size
+        logger.info("Disconnected all clients in OBSConnectionPool.")
+
+    def _check_and_reconnect(self, index):
+        """Checks a specific client and reconnects if necessary."""
+        client = self._clients[index]
+        if not client:
+            self._clients[index] = obs.ReqClient(**self.connection_kwargs)
+            logger.info(f"Re-initialized client {index} in pool.")
+            return
+        try:
+            client.get_version()
+        except Exception:
+            logger.info(f"Reconnecting client {index} in pool.")
+            try:
+                client.disconnect()
+            except Exception:
+                pass
+            self._clients[index] = obs.ReqClient(**self.connection_kwargs)
+
+    @contextlib.contextmanager
+    def get_client(self):
+        """A context manager to safely get a client from the pool."""
+        with self._idx_lock:
+            idx = self._next_idx
+            self._next_idx = (self._next_idx + 1) % self.size
+
+        lock = self._locks[idx]
+        lock.acquire()
+        try:
+            self._check_and_reconnect(idx)
+            yield self._clients[idx]
+        finally:
+            lock.release()
+
+    def get_healthcheck_client(self):
+        """Returns a dedicated client for health checks, separate from the main pool."""
+        if not hasattr(self, '_healthcheck_client') or self._healthcheck_client is None:
+            try:
+                self._healthcheck_client = obs.ReqClient(**self.connection_kwargs)
+                logger.info("Initialized dedicated healthcheck client.")
+            except Exception as e:
+                logger.error(f"Failed to create healthcheck client: {e}")
+                self._healthcheck_client = None
+        return self._healthcheck_client
+
+
 class OBSConnectionManager(threading.Thread):
     def __init__(self, check_output=True):
         super().__init__()
@@ -38,8 +114,11 @@ class OBSConnectionManager(threading.Thread):
         while self.running:
             time.sleep(self.check_connection_interval)
             try:
-                if not connecting:
+                client = connection_pool.get_healthcheck_client() if connection_pool else None
+                if client and not connecting:
                     client.get_version()
+                else:
+                    raise ConnectionError("Healthcheck client not healthy or not initialized")
             except Exception as e:
                 logger.info(f"OBS WebSocket not connected. Attempting to reconnect... {e}")
                 gsm_status.obs_connected = False
@@ -128,12 +207,12 @@ def start_obs():
         return None
 
 async def wait_for_obs_connected():
-    global client
-    if not client:
+    if not connection_pool:
         return False
     for _ in range(10):
         try:
-            response = client.get_version()
+            with connection_pool.get_client() as client:
+                response = client.get_version()
             if response:
                 return True
         except Exception as e:
@@ -183,19 +262,25 @@ def get_obs_websocket_config_values():
         reload_config()
 
 async def connect_to_obs(retry=5, check_output=True):
-    global client, obs_connection_manager, event_client, connecting
+    global connection_pool, obs_connection_manager, event_client, connecting
     if is_windows():
         get_obs_websocket_config_values()
 
     while True:
         connecting = True
         try:
-            client = obs.ReqClient(
-                host=get_config().obs.host,
-                port=get_config().obs.port,
-                password=get_config().obs.password,
-                timeout=1,
-            )
+            pool_kwargs = {
+                'host': get_config().obs.host,
+                'port': get_config().obs.port,
+                'password': get_config().obs.password,
+                'timeout': 3,
+            }
+            connection_pool = OBSConnectionPool(size=3, **pool_kwargs)
+            connection_pool.connect_all()
+
+            with connection_pool.get_client() as client:
+                client.get_version() # Test one connection to confirm it works
+
             event_client = obs.EventClient(
                 host=get_config().obs.host,
                 port=get_config().obs.port,
@@ -213,7 +298,7 @@ async def connect_to_obs(retry=5, check_output=True):
             if retry <= 0:
                 gsm_status.obs_connected = False
                 logger.error(f"Failed to connect to OBS WebSocket: {e}")
-                client = None
+                connection_pool = None
                 event_client = None
                 connecting = False
                 break
@@ -222,18 +307,24 @@ async def connect_to_obs(retry=5, check_output=True):
     connecting = False
 
 def connect_to_obs_sync(retry=2, check_output=True):
-    global client, obs_connection_manager, event_client
+    global connection_pool, obs_connection_manager, event_client
     if is_windows():
         get_obs_websocket_config_values()
 
     while True:
         try:
-            client = obs.ReqClient(
-                host=get_config().obs.host,
-                port=get_config().obs.port,
-                password=get_config().obs.password,
-                timeout=1,
-            )
+            pool_kwargs = {
+                'host': get_config().obs.host,
+                'port': get_config().obs.port,
+                'password': get_config().obs.password,
+                'timeout': 3,
+            }
+            connection_pool = OBSConnectionPool(size=5, **pool_kwargs)
+            connection_pool.connect_all()
+            
+            with connection_pool.get_client() as client:
+                client.get_version() # Test one connection to confirm it works
+
             event_client = obs.EventClient(
                 host=get_config().obs.host,
                 port=get_config().obs.port,
@@ -250,7 +341,7 @@ def connect_to_obs_sync(retry=2, check_output=True):
             if retry <= 0:
                 gsm_status.obs_connected = False
                 logger.error(f"Failed to connect to OBS WebSocket: {e}")
-                client = None
+                connection_pool = None
                 event_client = None
                 break
             time.sleep(1)
@@ -258,33 +349,44 @@ def connect_to_obs_sync(retry=2, check_output=True):
 
 
 def disconnect_from_obs():
-    global client
-    if client:
-        client.disconnect()
-        client = None
+    global connection_pool
+    if connection_pool:
+        connection_pool.disconnect_all()
+        connection_pool = None
         logger.info("Disconnected from OBS WebSocket.")
 
-def do_obs_call(request, *args, from_dict=None, retry=3):
-    connect_to_obs()
-    if not client:
+def do_obs_call(method_name: str, from_dict=None, retry=3, **kwargs):
+    if not connection_pool:
+        connect_to_obs_sync(retry=1)
+    if not connection_pool:
         return None
+
+    last_exception = None
     for _ in range(retry + 1):
         try:
-            response = request(*args)
-            if response and response.ok:
-                return from_dict(response.datain) if from_dict else response.datain
+            with connection_pool.get_client() as client:
+                method_to_call = getattr(client, method_name)
+                response = method_to_call(**kwargs)
+                if response and response.ok:
+                    return from_dict(response.datain) if from_dict else response.datain
             time.sleep(0.3)
+        except AttributeError:
+             logger.error(f"OBS client has no method '{method_name}'")
+             return None
         except Exception as e:
-            logger.error(f"Error calling OBS: {e}")
+            last_exception = e
+            logger.error(f"Error calling OBS ('{method_name}'): {e}")
             if "socket is already closed" in str(e) or "object has no attribute" in str(e):
                 time.sleep(0.3)
             else:
                 return None
+    logger.error(f"OBS call '{method_name}' failed after retries. Last error: {last_exception}")
     return None
 
 def toggle_replay_buffer():
     try:
-        response = client.toggle_replay_buffer()
+        with connection_pool.get_client() as client:
+            response = client.toggle_replay_buffer()
         if response:
             logger.info("Replay buffer Toggled.")
     except Exception as e:
@@ -292,7 +394,8 @@ def toggle_replay_buffer():
 
 def start_replay_buffer():
     try:
-        response = client.start_replay_buffer()
+        with connection_pool.get_client() as client:
+            response = client.start_replay_buffer()
         if response and response.ok:
             logger.info("Replay buffer started.")
     except Exception as e:
@@ -300,14 +403,16 @@ def start_replay_buffer():
 
 def get_replay_buffer_status():
     try:
-        return client.get_replay_buffer_status().output_active
+        with connection_pool.get_client() as client:
+            return client.get_replay_buffer_status().output_active
     except Exception as e:
         logger.debug(f"Error getting replay buffer status: {e}")
         return None
 
 def stop_replay_buffer():
     try:
-        response = client.stop_replay_buffer()
+        with connection_pool.get_client() as client:
+            response = client.stop_replay_buffer()
         if response and response.ok:
             logger.info("Replay buffer stopped.")
     except Exception as e:
@@ -316,7 +421,8 @@ def stop_replay_buffer():
 def save_replay_buffer():
     status = get_replay_buffer_status()
     if status:
-        response = client.save_replay_buffer()
+        with connection_pool.get_client() as client:
+            response = client.save_replay_buffer()
         if response and response.ok:
             logger.info("Replay buffer saved. If your log stops here, make sure your obs output path matches \"Path To Watch\" in GSM settings.")
     else:
@@ -324,7 +430,8 @@ def save_replay_buffer():
 
 def get_current_scene():
     try:
-        response = client.get_current_program_scene()
+        with connection_pool.get_client() as client:
+            response = client.get_current_program_scene()
         return response.scene_name if response else ''
     except Exception as e:
         logger.debug(f"Couldn't get scene: {e}")
@@ -332,7 +439,8 @@ def get_current_scene():
 
 def get_source_from_scene(scene_name):
     try:
-        response = client.get_scene_item_list(name=scene_name)
+        with connection_pool.get_client() as client:
+            response = client.get_scene_item_list(name=scene_name)
         return response.scene_items[0] if response and response.scene_items else ''
     except Exception as e:
         logger.error(f"Error getting source from scene: {e}")
@@ -346,7 +454,8 @@ def get_active_source():
 
 def get_record_directory():
     try:
-        response = client.get_record_directory()
+        with connection_pool.get_client() as client:
+            response = client.get_record_directory()
         return response.record_directory if response else ''
     except Exception as e:
         logger.error(f"Error getting recording folder: {e}")
@@ -354,17 +463,17 @@ def get_record_directory():
 
 def get_obs_scenes():
     try:
-        response = client.get_scene_list()
+        with connection_pool.get_client() as client:
+            response = client.get_scene_list()
         return response.scenes if response else None
     except Exception as e:
         logger.error(f"Error getting scenes: {e}")
         return None
 
 async def register_scene_change_callback(callback):
-    global client
     if await wait_for_obs_connected():
-        if not client:
-            logger.error("OBS client is not connected.")
+        if not connection_pool:
+            logger.error("OBS connection pool is not connected.")
             return
 
         def on_current_program_scene_changed(data):
@@ -391,7 +500,8 @@ def get_screenshot(compression=-1):
             return None
         start = time.time()
         logger.debug(f"Current source name: {current_source_name}")
-        client.save_source_screenshot(name=current_source_name, img_format='png', width=None, height=None, file_path=screenshot, quality=compression)
+        with connection_pool.get_client() as client:
+            client.save_source_screenshot(name=current_source_name, img_format='png', width=None, height=None, file_path=screenshot, quality=compression)
         logger.debug(f"Screenshot took {time.time() - start:.3f} seconds to save")
         return screenshot
     except Exception as e:
@@ -410,11 +520,10 @@ def get_screenshot_base64(compression=75, width=None, height=None):
         if not current_source_name:
             logger.error("No active source found in the current scene.")
             return None
-        # version = client.send("GetVersion", raw=True)
-        # pprint(version)
-        # responseraw = client.send("GetSourceScreenshot", {"sourceName": current_source_name, "imageFormat": "png", "imageWidth": width, "imageHeight": height, "compressionQuality": compression}, raw=True)
-        response = client.get_source_screenshot(name=current_source_name, img_format='png', quality=compression, width=width, height=height)
-        # print(responseraw)
+
+        with connection_pool.get_client() as client:
+            response = client.get_source_screenshot(name=current_source_name, img_format='png', quality=compression, width=width, height=height)
+
         if response and response.image_data:
             return response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
         else:
@@ -435,7 +544,8 @@ def get_screenshot_PIL(source_name=None, compression=75, img_format='png', width
         logger.error("No active source found in the current scene.")
         return None
     while True:
-        response = client.get_source_screenshot(name=source_name, img_format=img_format, quality=compression, width=width, height=height)
+        with connection_pool.get_client() as client:
+            response = client.get_source_screenshot(name=source_name, img_format=img_format, quality=compression, width=width, height=height)
         try:
             response.image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
         except AttributeError:
@@ -448,8 +558,6 @@ def get_screenshot_PIL(source_name=None, compression=75, img_format='png', width
             image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
             image_data = base64.b64decode(image_data)
             img = Image.open(io.BytesIO(image_data)).convert("RGBA")
-        # if width and height:
-            # img = img.resize((width, height), Image.Resampling.LANCZOS)
             return img
     return None
 
@@ -472,103 +580,84 @@ def get_current_game(sanitize=False, update=True):
 def set_fit_to_screen_for_scene_items(scene_name: str):
     """
     Sets all sources in a given scene to "Fit to Screen" (like Ctrl+F in OBS).
-
-    This function fetches the canvas dimensions, then iterates through all scene
-    items in the specified scene and applies a transform that scales them to
-    fit within the canvas while maintaining aspect ratio and centering them.
-
-    Args:
-        scene_name: The name of the scene to modify.
     """
+    if not scene_name:
+        return
+        
     try:
-        # 1. Get the canvas (base) resolution from OBS video settings
-        video_settings = client.get_video_settings()
-        if not hasattr(video_settings, 'base_width') or not hasattr(video_settings, 'base_height'):
-            logger.debug("Video settings do not have base_width or base_height attributes, probably weird websocket error issue? Idk what causes it..")
-            return
-        canvas_width = video_settings.base_width
-        canvas_height = video_settings.base_height
+        with connection_pool.get_client() as client:
+            # 1. Get the canvas (base) resolution from OBS video settings
+            video_settings = client.get_video_settings()
+            if not hasattr(video_settings, 'base_width') or not hasattr(video_settings, 'base_height'):
+                logger.debug("Video settings do not have base_width or base_height attributes, probably weird websocket error issue? Idk what causes it..")
+                return
+            canvas_width = video_settings.base_width
+            canvas_height = video_settings.base_height
 
-        # 2. Get the list of items in the specified scene
-        scene_items_response = client.get_scene_item_list(scene_name)
-        items = scene_items_response.scene_items if scene_items_response.scene_items else []
+            # 2. Get the list of items in the specified scene
+            scene_items_response = client.get_scene_item_list(scene_name)
+            items = scene_items_response.scene_items if scene_items_response.scene_items else []
 
-        if not items:
-            logger.warning(f"No items found in scene '{scene_name}'.")
-            return
+            if not items:
+                logger.warning(f"No items found in scene '{scene_name}'.")
+                return
 
-        # 3. Loop through each item and apply the "Fit to Screen" transform
-        for item in items:
-            item_id = item['sceneItemId']
-            source_name = item['sourceName']
-            
-            scene_item_transform = item.get('sceneItemTransform', {})
-            
-            source_width = scene_item_transform.get('sourceWidth', None)
-            source_height = scene_item_transform.get('sourceHeight', None)
-
-            aspect_ratio_different = False
-            already_cropped = any([
-                scene_item_transform.get('cropLeft', 0) != 0,
-                scene_item_transform.get('cropRight', 0) != 0,
-                scene_item_transform.get('cropTop', 0) != 0,
-                scene_item_transform.get('cropBottom', 0) != 0,
-            ])
-            
-            if source_width and source_height and not already_cropped:
-                source_aspect_ratio = source_width / source_height
-                canvas_aspect_ratio = canvas_width / canvas_height
-                # Check if aspect ratio is different and if it's a standard aspect ratio
-                aspect_ratio_different = abs(source_aspect_ratio - canvas_aspect_ratio) > 0.01
-
-                # List of standard aspect ratios
-                standard_ratios = [
-                    4 / 3,
-                    16 / 9,
-                    16 / 10,
-                    21 / 9,
-                    32 / 9,
-                    5 / 4,
-                    3 / 2,
-                ]
-
-                def is_standard_ratio(ratio):
-                    return any(abs(ratio - std) < 0.02 for std in standard_ratios)
-
-                # Only crop if both source and canvas are standard aspect ratios
-                if aspect_ratio_different:
-                    if not (is_standard_ratio(source_aspect_ratio) and is_standard_ratio(canvas_aspect_ratio)):
-                        aspect_ratio_different = False
-            
-            # This transform object is the equivalent of "Fit to Screen"
-            fit_to_screen_transform = {
-                'boundsType': 'OBS_BOUNDS_SCALE_INNER',
-                'alignment': 5,  # 5 = Center alignment (horizontal and vertical)
-                'boundsWidth': canvas_width,
-                'boundsHeight': canvas_height,
-                'positionX': 0,
-                'positionY': 0,
-            }
-            
-            if not already_cropped:
-                fit_to_screen_transform.update({
-                    'cropLeft': 0 if not aspect_ratio_different or canvas_width > source_width else (source_width - canvas_width) // 2,
-                    'cropRight': 0 if not aspect_ratio_different or canvas_width > source_width else (source_width - canvas_width) // 2,
-                    'cropTop': 0 if not aspect_ratio_different or canvas_height > source_height else (source_height - canvas_height) // 2,
-                    'cropBottom': 0 if not aspect_ratio_different or canvas_height > source_height else (source_height - canvas_height) // 2,
-                })
+            # 3. Loop through each item and apply the "Fit to Screen" transform
+            for item in items:
+                item_id = item['sceneItemId']
+                source_name = item['sourceName']
+                
+                scene_item_transform = item.get('sceneItemTransform', {})
+                
+                source_width = scene_item_transform.get('sourceWidth', None)
+                source_height = scene_item_transform.get('sourceHeight', None)
+
+                aspect_ratio_different = False
+                already_cropped = any([
+                    scene_item_transform.get('cropLeft', 0) != 0,
+                    scene_item_transform.get('cropRight', 0) != 0,
+                    scene_item_transform.get('cropTop', 0) != 0,
+                    scene_item_transform.get('cropBottom', 0) != 0,
+                ])
+                
+                if source_width and source_height and not already_cropped:
+                    source_aspect_ratio = source_width / source_height
+                    canvas_aspect_ratio = canvas_width / canvas_height
+                    aspect_ratio_different = abs(source_aspect_ratio - canvas_aspect_ratio) > 0.01
+
+                    standard_ratios = [4 / 3, 16 / 9, 16 / 10, 21 / 9, 32 / 9, 5 / 4, 3 / 2]
+
+                    def is_standard_ratio(ratio):
+                        return any(abs(ratio - std) < 0.02 for std in standard_ratios)
+
+                    if aspect_ratio_different:
+                        if not (is_standard_ratio(source_aspect_ratio) and is_standard_ratio(canvas_aspect_ratio)):
+                            aspect_ratio_different = False
+                
+                fit_to_screen_transform = {
+                    'boundsType': 'OBS_BOUNDS_SCALE_INNER', 'alignment': 5,
+                    'boundsWidth': canvas_width, 'boundsHeight': canvas_height,
+                    'positionX': 0, 'positionY': 0,
+                }
+                
+                if not already_cropped:
+                    fit_to_screen_transform.update({
+                        'cropLeft': 0 if not aspect_ratio_different or canvas_width > source_width else (source_width - canvas_width) // 2,
+                        'cropRight': 0 if not aspect_ratio_different or canvas_width > source_width else (source_width - canvas_width) // 2,
+                        'cropTop': 0 if not aspect_ratio_different or canvas_height > source_height else (source_height - canvas_height) // 2,
+                        'cropBottom': 0 if not aspect_ratio_different or canvas_height > source_height else (source_height - canvas_height) // 2,
+                    })
 
-            try:
-                client.set_scene_item_transform(
-                    scene_name=scene_name,
-                    item_id=item_id,
-                    transform=fit_to_screen_transform
-                )
-            except obs.error.OBSSDKError as e:
-                logger.error(f"Failed to set transform for source '{source_name}': {e}")
+                try:
+                    client.set_scene_item_transform(
+                        scene_name=scene_name,
+                        item_id=item_id,
+                        transform=fit_to_screen_transform
+                    )
+                except obs.error.OBSSDKError as e:
+                    logger.error(f"Failed to set transform for source '{source_name}': {e}")
 
     except obs.error.OBSSDKError as e:
-        # This will catch errors like "scene not found"
         logger.error(f"An OBS error occurred: {e}")
     except Exception as e:
         logger.error(f"An unexpected error occurred: {e}")
@@ -576,12 +665,14 @@ def set_fit_to_screen_for_scene_items(scene_name: str):
 
 def main():
     start_obs()
-    connect_to_obs()
+    # connect_to_obs() is async, main is not. Use the sync version.
+    connect_to_obs_sync()
     # Test each method
     print("Testing `get_obs_path`:", get_obs_path())
     print("Testing `is_process_running` with PID 1:", is_process_running(1))
     print("Testing `check_obs_folder_is_correct`:")
-    check_obs_folder_is_correct()
+    # This is async, need to run it in an event loop if testing from main
+    asyncio.run(check_obs_folder_is_correct())
     print("Testing `get_obs_websocket_config_values`:")
     try:
         get_obs_websocket_config_values()
@@ -595,10 +686,13 @@ def main():
     print("Testing `stop_replay_buffer`:")
     stop_replay_buffer()
     print("Testing `save_replay_buffer`:")
-    save_replay_buffer()
+    try:
+        save_replay_buffer()
+    except Exception as e:
+        print(f"Could not save replay buffer: {e}")
     current_scene = get_current_scene()
     print("Testing `get_current_scene`:", current_scene)
-    print("Testing `get_source_from_scene` with dummy scene:", get_source_from_scene(current_scene))
+    print("Testing `get_source_from_scene` with current scene:", get_source_from_scene(current_scene))
     print("Testing `get_record_directory`:", get_record_directory())
     print("Testing `get_obs_scenes`:", get_obs_scenes())
     print("Testing `get_screenshot`:", get_screenshot())
@@ -612,51 +706,4 @@ def main():
 if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO)
     connect_to_obs_sync()
-    set_fit_to_screen_for_scene_items(get_current_scene())
-    # main()
-    # connect_to_obs_sync()
-    # img = get_screenshot_PIL(source_name="Display Capture 2", compression=75, img_format='png', width=1280, height=720)
-    # img.show()
-    # while True:
-    #     print(get_active_source())
-    #     time.sleep(3)
-    # i = 100
-    # for i in range(1, 100):
-    #     print(f"Getting screenshot {i}")
-    #     start = time.time()
-    # # get_screenshot(compression=95)
-    # # get_screenshot_base64(compression=95, width=1280, height=720)
-    
-    #     img = get_screenshot_PIL(compression=i, img_format='jpg', width=1280, height=720)
-    #     end = time.time()
-    #     print(f"Time taken to get screenshot with compression {i}: {end - start} seconds")
-        
-    # for i in range(1, 100):
-    #     print(f"Getting screenshot {i}")
-    #     start = time.time()
-    # # get_screenshot(compression=95)
-    # # get_screenshot_base64(compression=95, width=1280, height=720)
-    
-    #     img = get_screenshot_PIL(compression=i, img_format='jpg', width=2560, height=1440)
-    #     end = time.time()
-    #     print(f"Time taken to get screenshot full sized jpg with compression {i}: {end - start} seconds")
-
-    # png_img = get_screenshot_PIL(compression=75, img_format='png', width=1280, height=720)
-
-    # jpg_img = get_screenshot_PIL(compression=100, img_format='jpg', width=2560, height=1440)
-
-    # png_img.show()
-    # jpg_img.show()
-    
-    # start = time.time()
-    # with mss() as sct:
-    #     monitor = sct.monitors[1]
-    #     sct_img = sct.grab(monitor)
-    #     img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
-    #     img.show()
-    # end = time.time()
-    # print(f"Time taken to get screenshot with mss: {end - start} seconds")
-
-    
-    # print(get_screenshot_base64(compression=75, width=1280, height=720))
-
+    set_fit_to_screen_for_scene_items(get_current_scene())

GameSentenceMiner/ocr/owocr_helper.py

@@ -577,7 +577,7 @@ if __name__ == "__main__":
         keep_newline = args.keep_newline
         obs_ocr = args.obs_ocr
         
-        obs.connect_to_obs_sync(retry=0, check_output=False)
+        obs.connect_to_obs_sync(check_output=False)
     
         # Start config change checker thread
         config_check_thread = ConfigChangeCheckThread()

GameSentenceMiner/owocr/owocr/ocr.py

@@ -1014,7 +1014,6 @@ class OneOCR:
                     res = ocr_resp['text']
                     
                 if multiple_crop_coords:
-                    logger.info(f"Getting multiple crop coords for {len(filtered_lines)} lines")
                     for line in filtered_lines:
                         crop_coords_list.append(
                             (line['bounding_rect']['x1'] - 5, line['bounding_rect']['y1'] - 5,
@@ -1434,13 +1433,10 @@ class localLLMOCR:
             self.keep_warm = config.get('keep_warm', True)
             self.custom_prompt = config.get('prompt', None)
             self.available = True
-            if any(x in self.api_url for x in ['localhost', '127.0.0.1']):
-                if not self.check_connection(self.api_url):
-                    logger.warning('Local LLM OCR API is not reachable')
-                    return
             self.client = openai.OpenAI(
                 base_url=self.api_url.replace('/v1/chat/completions', '/v1'),
-                api_key=self.api_key
+                api_key=self.api_key,
+                timeout=3
             )
             if self.client.models.retrieve(self.model):
                 self.model = self.model
@@ -1450,24 +1446,6 @@ class localLLMOCR:
                 self.keep_llm_hot_thread.start()
         except Exception as e:
             logger.warning(f'Error initializing Local LLM OCR, Local LLM OCR will not work!')
-            
-    def check_connection(self, url, port=None):
-        import http.client
-        conn = http.client.HTTPConnection(url, port or 1234, timeout=0.1)
-        try:
-            conn.request("GET", "/v1/models")
-            response = conn.getresponse()
-            if response.status == 200:
-                logger.info('Local LLM OCR API is reachable')
-                return True
-            else:
-                logger.warning('Local LLM OCR API is not reachable')
-                return False
-        except Exception as e:
-            logger.warning(f'Error connecting to Local LLM OCR API: {e}')
-            return False
-        finally:
-            conn.close()
         
     def keep_llm_warm(self):
         def ocr_blank_black_image():

GameSentenceMiner/util/configuration.py

@@ -559,6 +559,7 @@ class VAD:
     add_audio_on_no_results: bool = False
     cut_and_splice_segments: bool = False
     splice_padding: float = 0.1
+    use_cpu_for_inference: bool = False
 
     def is_silero(self):
         return self.selected_vad_model == SILERO or self.backup_vad_model == SILERO

GameSentenceMiner/util/get_overlay_coords.py

@@ -104,7 +104,6 @@ class OverlayProcessor:
         """
         with mss.mss() as sct:
             monitors = sct.monitors[1:]
-            print(monitors)
             if is_windows() and monitor_index == 0:
                 from ctypes import wintypes
                 import ctypes

GameSentenceMiner/vad.py

@@ -167,7 +167,8 @@ class WhisperVADProcessor(VADProcessor):
         import stable_whisper as whisper
         if not self.vad_model:
             with warnings.catch_warnings():
-                self.vad_model = whisper.load_model(get_config().vad.whisper_model)
+                warnings.simplefilter("ignore")
+                self.vad_model = whisper.load_model(get_config().vad.whisper_model, device="cpu" if get_config().vad.use_cpu_for_inference else None)
             logger.info(f"Whisper model '{get_config().vad.whisper_model}' loaded.")
         return self.vad_model
 
@@ -181,6 +182,7 @@ class WhisperVADProcessor(VADProcessor):
 
         # Transcribe the audio using Whisper
         with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
             result: WhisperResult = self.vad_model.transcribe(temp_wav, vad=True, language=get_config().vad.language,
                                                              temperature=0.0)
         voice_activity = []

{gamesentenceminer-2.15.2.dist-info → gamesentenceminer-2.15.4.dist-info}/METADATA

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

{gamesentenceminer-2.15.2.dist-info → gamesentenceminer-2.15.4.dist-info}/RECORD

@@ -1,10 +1,10 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/anki.py,sha256=4Tq6OGjfN-5tYorYRWiih7FZjSKMG6amrLv6DFKkFQc,25344
-GameSentenceMiner/config_gui.py,sha256=G36MLR1UcdiLB6V3T25_ggGVnt5B4Vj1pS76nQQMqpk,139669
+GameSentenceMiner/config_gui.py,sha256=i79PrY2pP8_VKvIL7uoDv5cgHvCCQBIe0mS_YnX2AVg,140792
 GameSentenceMiner/gametext.py,sha256=fgBgLchezpauWELE9Y5G3kVCLfAneD0X4lJFoI3FYbs,10351
 GameSentenceMiner/gsm.py,sha256=4mJn5v4WKqKAJEtph5e0v4YPVDOpvFN1ylV2vQvf_Dg,31913
-GameSentenceMiner/obs.py,sha256=99V4WvBhbBTEGI1o3dlGzhqnktKFUxPc1-5vOBcV0lk,26296
-GameSentenceMiner/vad.py,sha256=YCn4ZIc6_Q3IGOr5QNMiheVT3Ma5nisn8-V8xD53Mw4,19236
+GameSentenceMiner/obs.py,sha256=eejvd6N7_3YeC0FwED9WOZAeYmKWkA27vNT7ylh0B8k,28722
+GameSentenceMiner/vad.py,sha256=EEUFLDbkJ4jYmctfVaV99BwMNRuLx7DLRTYmKUo-myw,19394
 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
@@ -15,20 +15,20 @@ GameSentenceMiner/assets/icon32.png,sha256=Kww0hU_qke9_22wBuO_Nq0Dv2SfnOLwMhCyGg
 GameSentenceMiner/assets/icon512.png,sha256=HxUj2GHjyQsk8NV433256UxU9phPhtjCY-YB_7W4sqs,192487
 GameSentenceMiner/assets/icon64.png,sha256=N8xgdZXvhqVQP9QUK3wX5iqxX9LxHljD7c-Bmgim6tM,9301
 GameSentenceMiner/assets/pickaxe.png,sha256=VfIGyXyIZdzEnVcc4PmG3wszPMO1W4KCT7Q_nFK6eSE,1403829
-GameSentenceMiner/locales/en_us.json,sha256=FAnvsCfsFzWyxYKZKh8HKHsAahi3Oa4wGVekTTN2WGI,26587
-GameSentenceMiner/locales/ja_jp.json,sha256=-v0ng0psD88-C4XjYazJL0Rn0gwQU7b2VYspvdatDO4,28326
-GameSentenceMiner/locales/zh_cn.json,sha256=X5nw6tsu7ACaZIuSUDSUUjG8qPUwmqyG3TKcPbWSIYw,24654
+GameSentenceMiner/locales/en_us.json,sha256=4lCV34FnDOe0c02qHlHnfujQedmqHSL-feN3lYCCCfs,26744
+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/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
 GameSentenceMiner/ocr/owocr_area_selector.py,sha256=Rm1_nuZotJhfOfoJ_3mesh9udtOBjYqKhnAvSief6fo,29181
-GameSentenceMiner/ocr/owocr_helper.py,sha256=8aIpAHSPPByox5qcU4SX-_ECDgQZVEwrXdj4A8AQZ6U,28437
+GameSentenceMiner/ocr/owocr_helper.py,sha256=0pzeWY0L49pH_KjAg4enmg5t_Om0wFb4R2BTP6yBISI,28428
 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=rJKmB8xtSVrayq8XcZ4JKBULyPKDqfJDGKgLjICbUX8,71021
+GameSentenceMiner/owocr/owocr/ocr.py,sha256=JXUboda00-1GYzYYDTiYcPaeWKKwvMdQ-q_CHVB7h10,70014
 GameSentenceMiner/owocr/owocr/run.py,sha256=xbBpyFCVfITZDztsRLT8_sX6BGf1o5LxOPxE9zUWfQc,79975
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSdbN3QhEswtKuU1JjReFk_K8t5ezQE,3395
 GameSentenceMiner/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -37,11 +37,11 @@ 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=JVwaqvfrUrOUiA0kZcznDsCo9hJkJqBpVztyI6JA-YU,40201
+GameSentenceMiner/util/configuration.py,sha256=cpgusOu4lItCBsZyB8QoAJaXjDovIXNlqyKzh2GMYzw,40241
 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
-GameSentenceMiner/util/get_overlay_coords.py,sha256=bSvBSvLFmABogPp-quXcQrN-meWvl5NRB6gFEluoNNg,15142
+GameSentenceMiner/util/get_overlay_coords.py,sha256=P5tI7H0cnveGs33aQdvJGy9DV6aIAGh8K8Al1XjNPzw,15114
 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
@@ -72,9 +72,9 @@ GameSentenceMiner/web/templates/index.html,sha256=LqXZx7-NE42pXSpHNZ3To680rD-vt9
 GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
 GameSentenceMiner/web/templates/utility.html,sha256=3flZinKNqUJ7pvrZk6xu__v67z44rXnaK7UTZ303R-8,16946
 GameSentenceMiner/wip/__init___.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gamesentenceminer-2.15.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.15.2.dist-info/METADATA,sha256=G5LgyYGod4vrUBzQESiCd7p8CQwBybDYTVXy7Fkv_M8,7317
-gamesentenceminer-2.15.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.15.2.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.15.2.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.15.2.dist-info/RECORD,,
+gamesentenceminer-2.15.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.15.4.dist-info/METADATA,sha256=kiXbjNcMkmEwfiVBKr3AH0Wtil4Hxe32XJWNPJjulHE,7317
+gamesentenceminer-2.15.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.15.4.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.15.4.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.15.4.dist-info/RECORD,,