GameSentenceMiner 2.16.12__tar.gz → 2.17.0__tar.gz

{gamesentenceminer-2.16.12 → gamesentenceminer-2.17.0}/GameSentenceMiner/anki.py

@@ -490,6 +490,7 @@ def update_card_from_same_sentence(last_card, lines, game_line):
                 card_queue.pop(0)
                 logger.error(f"Error saving replay buffer: {e}")
                 return
+            return
     anki_result = anki_results[game_line.id]
     if anki_result.success:
         note, last_card = get_initial_card_info(last_card, lines)

{gamesentenceminer-2.16.12 → gamesentenceminer-2.17.0}/GameSentenceMiner/gametext.py

@@ -83,6 +83,7 @@ async def listen_websockets():
                     line_time = None
                     while True:
                         message = await websocket.recv()
+                        message_received_time = datetime.now()
                         if not message:
                             continue
                         logger.debug(message)
@@ -97,7 +98,7 @@ async def listen_websockets():
                         logger.info
                         if current_clipboard != current_line:
                             try:
-                                await handle_new_text_event(current_clipboard, line_time if line_time else None)
+                                await handle_new_text_event(current_clipboard, line_time if line_time else message_received_time)
                             except Exception as e: 
                                 logger.error(f"Error handling new text event: {e}", exc_info=True)
             except (websockets.ConnectionClosed, ConnectionError, InvalidStatus, ConnectionResetError, Exception) as e:

{gamesentenceminer-2.16.12 → gamesentenceminer-2.17.0}/GameSentenceMiner/obs.py

@@ -6,6 +6,7 @@ import threading
 import time
 import logging
 import contextlib
+import shutil
 
 import psutil
 
@@ -189,13 +190,24 @@ def start_obs():
             except ValueError:
                 print("Invalid PID found in file. Launching new OBS instance.")
             except OSError:
-                print("No process found with the stored PID. Launching new OBS instance.")
+                print("No process found with the stored PID. Launching new OBS instance.")   
 
     obs_path = get_obs_path()
     if not os.path.exists(obs_path):
         print(f"OBS not found at {obs_path}. Please install OBS.")
         return None
     try:
+        sentinel_folder = os.path.join(configuration.get_app_directory(), 'obs-studio', 'config', 'obs-studio', '.sentinel')
+        if os.path.exists(sentinel_folder):
+            try:
+                if os.path.isdir(sentinel_folder):
+                    shutil.rmtree(sentinel_folder)
+                else:
+                    os.remove(sentinel_folder)
+                print(f"Deleted sentinel folder: {sentinel_folder}")
+            except Exception as e:
+                print(f"Failed to delete sentinel folder: {e}")
+        
         obs_process = subprocess.Popen([obs_path, '--disable-shutdown-check', '--portable', '--startreplaybuffer', ], cwd=os.path.dirname(obs_path))
         obs_process_pid = obs_process.pid
         with open(OBS_PID_FILE, "w") as f:
@@ -663,8 +675,23 @@ def main():
     update_current_game()
     print("Testing `get_current_game`:", get_current_game())
     disconnect_from_obs()
+    
+def create_scene():
+    with connection_pool.get_client() as client:
+        # Extract fields from request_json
+        request_json = r'{"sceneName":"SILENT HILL f","inputName":"SILENT HILL f - Capture","inputKind":"window_capture","inputSettings":{"mode":"window","window":"SILENT HILL f  :UnrealWindow:SHf-Win64-Shipping.exe","capture_audio":true,"cursor":false,"method":"2"}}'
+        request_dict = json.loads(request_json)
+        scene_name = request_dict.get('sceneName')
+        input_name = request_dict.get('inputName')
+        input_kind = request_dict.get('inputKind')
+        input_settings = request_dict.get('inputSettings')
+        input_settings['method'] = 2
+        # Remove sceneName from request_dict if needed for create_input
+        request_dict.pop('sceneName', None)
+        response = client.create_input(inputName=input_name, inputKind=input_kind, sceneName=scene_name, inputSettings=input_settings, sceneItemEnabled=True)
 
 if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO)
     connect_to_obs_sync()
-    set_fit_to_screen_for_scene_items(get_current_scene())
+    # set_fit_to_screen_for_scene_items(get_current_scene())
+    create_scene()

{gamesentenceminer-2.16.12 → gamesentenceminer-2.17.0}/GameSentenceMiner/ocr/owocr_area_selector.py

@@ -328,6 +328,7 @@ class ScreenSelector:
             "How to Use:\n"
             "  • Left Click + Drag: Create a capture area (green).\n"
             "  • Shift + Left Click + Drag: Create an exclusion area (orange).\n"
+            "  • Ctrl + Left Click + Drag: Create a secondary (menu) area (purple).\n"
             "  • Right-Click on a box: Delete it.\n\n"
             "Hotkeys:\n"
             "  • Ctrl + S: Save and Quit\n"

{gamesentenceminer-2.16.12 → gamesentenceminer-2.17.0}/GameSentenceMiner/util/get_overlay_coords.py

@@ -9,11 +9,11 @@ import time
 from PIL import Image
 from typing import Dict, Any, List, Tuple
 import json
-from rapidfuzz.distance import Levenshtein
+from rapidfuzz import fuzz
 
 # Local application imports
 from GameSentenceMiner.ocr.gsm_ocr_config import set_dpi_awareness
-from GameSentenceMiner.util.configuration import OverlayEngine, get_config, is_windows, is_beangate, logger
+from GameSentenceMiner.util.configuration import OverlayEngine, get_config, get_temporary_directory, is_windows, is_beangate, logger
 from GameSentenceMiner.util.electron_config import get_ocr_language
 from GameSentenceMiner.obs import get_screenshot_PIL
 from GameSentenceMiner.web.texthooking_page import send_word_coordinates_to_overlay
@@ -93,7 +93,8 @@ class OverlayThread(threading.Thread):
         super().__init__()
         self.overlay_processor = OverlayProcessor()
         self.loop = asyncio.new_event_loop()
-        self.daemon = True  # Ensure thread exits when main program exits
+        self.daemon = True
+        self.first_time_run = True
 
     def run(self):
         """Runs the overlay processing loop."""
@@ -103,11 +104,18 @@ class OverlayThread(threading.Thread):
     async def overlay_loop(self):
         """Main loop to periodically process and send overlay data."""
         while True:
-            if get_config().overlay.periodic and overlay_server_thread.has_clients():
-                await self.overlay_processor.find_box_and_send_to_overlay('')
-                await asyncio.sleep(get_config().overlay.periodic_interval)  # Adjust the interval as needed
+            if overlay_server_thread.has_clients():
+                if get_config().overlay.periodic:
+                    await self.overlay_processor.find_box_and_send_to_overlay('')
+                    await asyncio.sleep(get_config().overlay.periodic_interval)
+                elif self.first_time_run:
+                    await self.overlay_processor.find_box_and_send_to_overlay('')
+                    self.first_time_run = False
+                else:
+                    await asyncio.sleep(3)
             else:
-                await asyncio.sleep(3)  # Sleep briefly when not active
+                self.first_time_run = True
+                await asyncio.sleep(3)
 
 class OverlayProcessor:
     """
@@ -125,6 +133,8 @@ class OverlayProcessor:
         self.lens = None
         self.regex = None
         self.ready = False
+        self.last_oneocr_result = None
+        self.last_lens_result = None
 
         try:
             if self.config.overlay.websocket_port and all([GoogleLens, get_regex]):
@@ -221,6 +231,8 @@ class OverlayProcessor:
             monitor = self.get_monitor_workarea(0)  # Get primary monitor work area
             sct_img = sct.grab(monitor)
             img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
+            
+            img.save(os.path.join(get_temporary_directory(), "latest_overlay_screenshot.png"))
                 
             return img, monitor['width'], monitor['height']
 
@@ -261,6 +273,8 @@ class OverlayProcessor:
             paste_x = math.floor(x1)
             paste_y = math.floor(y1)
             composite_img.paste(cropped_image, (paste_x, paste_y))
+            
+        composite_img.save(os.path.join(get_temporary_directory(), "latest_overlay_screenshot_trimmed.png"))
         
         return composite_img
 
@@ -277,7 +291,7 @@ class OverlayProcessor:
             return []
         if self.oneocr:
             # 2. Use OneOCR to find general text areas (fast)
-            _, _, oneocr_results, crop_coords_list = self.oneocr(
+            res, text, oneocr_results, crop_coords_list = self.oneocr(
                 full_screenshot,
                 return_coords=True,
                 multiple_crop_coords=True,
@@ -285,8 +299,19 @@ class OverlayProcessor:
                 furigana_filter_sensitivity=None, # Disable furigana filtering
             )
             
+            text_str = "".join([text for text in text if self.regex.match(text)])
+            
+            # RapidFuzz fuzzy match 90% to not send the same results repeatedly
+            if self.last_oneocr_result:
+                
+                score = fuzz.ratio(text_str, self.last_oneocr_result)
+                if score >= 80:
+                    logger.info("OneOCR results are similar to the last results (score: %d). Skipping overlay update.", score)
+                    return
+            self.last_oneocr_result = text_str
+
             logger.info("Sending OneOCR results to overlay.")
-            await send_word_coordinates_to_overlay(oneocr_results)
+            await send_word_coordinates_to_overlay(self._convert_oneocr_results_to_percentages(oneocr_results, monitor_width, monitor_height))
             
             # If User Home is beangate
             if is_beangate:
@@ -317,9 +342,19 @@ class OverlayProcessor:
         if len(res) != 3:
             return
         
-        _, _, coords = res
+        success, text_list, coords = res
+        
+        text_str = "".join([text for text in text_list if self.regex.match(text)])
+        
+        # RapidFuzz fuzzy match 90% to not send the same results repeatedly
+        if self.last_lens_result:
+            score = fuzz.ratio(text_str, self.last_lens_result)
+            if score >= 80:
+                logger.info("Google Lens results are similar to the last results (score: %d). Skipping overlay update.", score)
+                return
+        self.last_lens_result = text_str
 
-        if not res or not coords:
+        if not success or not coords:
             return
         
         # 5. Process the high-accuracy results into the desired format
@@ -433,6 +468,38 @@ class OverlayProcessor:
             "x3": center_x + half_w, "y3": center_y + half_h,
             "x4": center_x - half_w, "y4": center_y + half_h,
         }
+        
+    def _convert_oneocr_results_to_percentages(
+        self,
+        oneocr_results: List[Dict[str, Any]],
+        monitor_width: int,
+        monitor_height: int
+    ) -> List[Dict[str, Any]]:
+        """
+        Converts OneOCR results with pixel coordinates to percentages relative to the monitor size.
+        """
+        converted_results = []
+        for item in oneocr_results:
+            bbox = item.get("bounding_rect", {})
+            if not bbox:
+                continue
+            # Convert each coordinate to a percentage of the monitor dimensions
+            converted_bbox = {
+                key: (value / monitor_width if "x" in key else value / monitor_height)
+                for key, value in bbox.items()
+            }
+            converted_item = item.copy()
+            converted_item["bounding_rect"] = converted_bbox
+            converted_results.append(converted_item)
+            for word in converted_item.get("words", []):
+                word_bbox = word.get("bounding_rect", {})
+                if word_bbox:
+                    word["bounding_rect"] = {
+                        key: (value / monitor_width if "x" in key else value / monitor_height)
+                        for key, value in word_bbox.items()
+                    }
+        # logger.info(f"Converted OneOCR results to percentages: {converted_results}")
+        return converted_results
 
 async def main_test_screenshot():
     """

{gamesentenceminer-2.16.12 → gamesentenceminer-2.17.0}/GameSentenceMiner/web/database_api.py

@@ -335,8 +335,8 @@ def register_database_api_routes(app):
             if afk_timer is not None:
                 try:
                     afk_timer = int(afk_timer)
-                    if afk_timer < 30 or afk_timer > 600:
-                        return jsonify({'error': 'AFK timer must be between 30 and 600 seconds'}), 400
+                    if afk_timer < 0 or afk_timer > 600:
+                        return jsonify({'error': 'AFK timer must be between 0 and 600 seconds'}), 400
                     settings_to_update['afk_timer_seconds'] = afk_timer
                 except (ValueError, TypeError):
                     return jsonify({'error': 'AFK timer must be a valid integer'}), 400
@@ -344,8 +344,8 @@ def register_database_api_routes(app):
             if session_gap is not None:
                 try:
                     session_gap = int(session_gap)
-                    if session_gap < 300 or session_gap > 7200:
-                        return jsonify({'error': 'Session gap must be between 300 and 7200 seconds (5 minutes to 2 hours)'}), 400
+                    if session_gap < 0 or session_gap > 7200:
+                        return jsonify({'error': 'Session gap must be between 0 and 7200 seconds (0 to 2 hours)'}), 400
                     settings_to_update['session_gap_seconds'] = session_gap
                 except (ValueError, TypeError):
                     return jsonify({'error': 'Session gap must be a valid integer'}), 400

{gamesentenceminer-2.16.12 → gamesentenceminer-2.17.0}/GameSentenceMiner/web/static/js/shared.js

@@ -392,8 +392,8 @@ class SettingsManager {
             
             if (this.afkTimerInput) {
                 const afkTimer = parseInt(this.afkTimerInput.value);
-                if (isNaN(afkTimer) || afkTimer < 30 || afkTimer > 600) {
-                    this.showError('AFK timer must be between 30 and 600 seconds');
+                if (isNaN(afkTimer) || afkTimer < 0 || afkTimer > 600) {
+                    this.showError('AFK timer must be between 0 and 600 seconds');
                     return;
                 }
                 settings.afk_timer_seconds = afkTimer;
@@ -401,8 +401,8 @@ class SettingsManager {
             
             if (this.sessionGapInput) {
                 const sessionGap = parseInt(this.sessionGapInput.value);
-                if (isNaN(sessionGap) || sessionGap < 300 || sessionGap > 7200) {
-                    this.showError('Session gap must be between 300 and 7200 seconds');
+                if (isNaN(sessionGap) || sessionGap < 0 || sessionGap > 7200) {
+                    this.showError('Session gap must be between 0 and 7200 seconds (0 to 2 hours)');
                     return;
                 }
                 settings.session_gap_seconds = sessionGap;

{gamesentenceminer-2.16.12 → gamesentenceminer-2.17.0}/GameSentenceMiner.egg-info/PKG-INFO

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

{gamesentenceminer-2.16.12 → gamesentenceminer-2.17.0}/PKG-INFO

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

{gamesentenceminer-2.16.12 → gamesentenceminer-2.17.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GameSentenceMiner"
-version = "2.16.12"
+version = "2.17.0"
 description = "A tool for mining sentences from games. Update: Overlay?"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -57,7 +57,7 @@ dependencies = [
   "obsws-python~=1.7.2",
   "numpy==2.2.6",
   "regex",
-  "faster-whisper~=1.2.0"
+  "faster-whisper~=1.2.0",
 ]
 
 # This creates a command-line script named `gamesentenceminer` that will

{gamesentenceminer-2.16.12 → gamesentenceminer-2.17.0}/GameSentenceMiner/config_gui.py

@@ -417,10 +417,10 @@ class ConfigApp:
         self.create_screenshot_tab()
         self.create_audio_tab()
         self.create_obs_tab()
-        self.create_profiles_tab()
         self.create_ai_tab()
         self.create_advanced_tab()
         self.create_overlay_tab()
+        self.create_profiles_tab()
         # self.create_wip_tab()
 
     def add_reset_button(self, frame, category, row, column=0, recreate_tab=None):