GameSentenceMiner 2.17.0__tar.gz → 2.17.2__tar.gz

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

@@ -1,4 +1,8 @@
 import copy
+import json
+import os
+import shutil
+import threading
 from pathlib import Path
 import queue
 import time
@@ -15,8 +19,8 @@ from GameSentenceMiner.util.db import GameLinesTable
 from GameSentenceMiner.util.gsm_utils import make_unique, sanitize_filename, wait_for_stable_file, remove_html_and_cloze_tags, combine_dialogue, \
     run_new_thread, open_audio_in_external
 from GameSentenceMiner.util import ffmpeg, notification
-from GameSentenceMiner.util.configuration import *
-from GameSentenceMiner.util.configuration import get_config
+from GameSentenceMiner.util.configuration import get_config, AnkiUpdateResult, logger, anki_results, gsm_status, \
+    gsm_state
 from GameSentenceMiner.util.model import AnkiCard
 from GameSentenceMiner.util.text_log import get_all_lines, get_text_event, get_mined_line, lines_match
 from GameSentenceMiner.obs import get_current_game
@@ -554,16 +558,40 @@ def start_monitoring_anki():
 
 # --- Anki Stats Kanji Extraction Utilities ---
 
-def get_all_anki_first_field_kanji():
+def get_anki_earliest_date():
+    """
+    Fetches the earliest Anki card ID.
+    """
+    try:
+        note_ids = invoke("findCards", query="")
+        if not note_ids:
+            return 0
+        
+        # Return the first card ID as the "earliest"
+        # return note_ids[0]
+        return min(note_ids)
+        
+    except Exception as e:
+        logger.error(f"Failed to fetch kanji from Anki: {e}")
+        return 0
+
+def get_all_anki_first_field_kanji(start_timestamp = None, end_timestamp = None):
     """
     Fetch all notes from Anki and extract unique kanji from the first field of each note.
     Returns a set of kanji characters.
+    Optional filtering by start_timestamp and end_timestamp on note IDs.
     """
     from GameSentenceMiner.web.stats import is_kanji
     try:
         note_ids = invoke("findNotes", query="")
         if not note_ids:
             return set()
+        
+        # Filter note IDs by start and end timestamps if provided
+        if (start_timestamp and end_timestamp):
+            note_ids = [nid for nid in note_ids if int(start_timestamp) <= nid <= int(end_timestamp)]
+            if not note_ids:
+                return set()
         kanji_set = set()
         batch_size = 1000
         for i in range(0, len(note_ids), batch_size):

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

@@ -1,7 +1,9 @@
 import asyncio
 import copy
 import json
+import os
 import subprocess
+import sys
 import time
 import tkinter as tk
 from tkinter import filedialog, messagebox, simpledialog, scrolledtext, font
@@ -12,7 +14,11 @@ import ttkbootstrap as ttk
 from GameSentenceMiner import obs
 from GameSentenceMiner.util import configuration
 from GameSentenceMiner.util.communication.send import send_restart_signal
-from GameSentenceMiner.util.configuration import *
+from GameSentenceMiner.util.configuration import Config, Locale, logger, CommonLanguages, ProfileConfig, General, Paths, \
+    Anki, Features, Screenshot, Audio, OBS, Hotkeys, VAD, Overlay, Ai, Advanced, OverlayEngine, get_app_directory, \
+    get_config, is_beangate, AVAILABLE_LANGUAGES, WHSIPER_LARGE, WHISPER_TINY, WHISPER_BASE, WHISPER_SMALL, \
+    WHISPER_MEDIUM, WHISPER_TURBO, SILERO, WHISPER, OFF, gsm_state, DEFAULT_CONFIG, get_latest_version, \
+    get_current_version, AI_GEMINI, AI_GROQ, AI_OPENAI, save_full_config, get_default_anki_media_collection_path
 from GameSentenceMiner.util.db import AIModelsTable
 from GameSentenceMiner.util.downloader.download_tools import download_ocenaudio_if_needed
     
@@ -378,6 +384,7 @@ class ConfigApp:
         self.ocr_websocket_port_value = tk.StringVar(value=str(self.settings.advanced.ocr_websocket_port))
         self.texthooker_communication_websocket_port_value = tk.StringVar(value=str(self.settings.advanced.texthooker_communication_websocket_port))
         self.plaintext_websocket_export_port_value = tk.StringVar(value=str(self.settings.advanced.plaintext_websocket_port))
+        self.localhost_bind_address_value = tk.StringVar(value=self.settings.advanced.localhost_bind_address)
         
         # AI Settings
         self.ai_enabled_value = tk.BooleanVar(value=self.settings.ai.enabled)
@@ -401,6 +408,7 @@ class ConfigApp:
         self.overlay_engine_value = tk.StringVar(value=self.settings.overlay.engine)
         self.periodic_value = tk.BooleanVar(value=self.settings.overlay.periodic)
         self.periodic_interval_value = tk.StringVar(value=str(self.settings.overlay.periodic_interval))
+        self.scan_delay_value = tk.StringVar(value=str(self.settings.overlay.scan_delay))
         
         # Master Config Settings
         self.switch_to_default_if_not_found_value = tk.BooleanVar(value=self.master_config.switch_to_default_if_not_found)
@@ -615,6 +623,7 @@ class ConfigApp:
                 ocr_websocket_port=int(self.ocr_websocket_port_value.get()),
                 texthooker_communication_websocket_port=int(self.texthooker_communication_websocket_port_value.get()),
                 plaintext_websocket_port=int(self.plaintext_websocket_export_port_value.get()),
+                localhost_bind_address=self.localhost_bind_address_value.get(),
             ),
             ai=Ai(
                 enabled=self.ai_enabled_value.get(),
@@ -637,6 +646,7 @@ class ConfigApp:
                 websocket_port=int(self.overlay_websocket_port_value.get()),
                 monitor_to_capture=self.overlay_monitor.current() if self.monitors else 0,
                 engine=OverlayEngine(self.overlay_engine_value.get()).value if self.overlay_engine_value.get() else OverlayEngine.LENS.value,
+                scan_delay=float(self.scan_delay_value.get()),
                 periodic=self.periodic_value.get(),
                 periodic_interval=self.periodic_interval_value.get(),
             )
@@ -1992,6 +2002,12 @@ class ConfigApp:
         ttk.Entry(advanced_frame, textvariable=self.polling_rate_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
         
+        localhost_bind_address_i18n = advanced_i18n.get('localhost_bind_address', {})
+        HoverInfoLabelWidget(advanced_frame, text=localhost_bind_address_i18n.get('label', 'LocalHost Bind Address:'),
+                             tooltip=localhost_bind_address_i18n.get('tooltip', 'Set this to 0.0.0.0 if you want to connect from another device in your LAN, otherwise leave as is.'), row=self.current_row, column=0)
+        ttk.Entry(advanced_frame, textvariable=self.localhost_bind_address_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        self.current_row += 1
+
         current_ver_i18n = advanced_i18n.get('current_version', {})
         HoverInfoLabelWidget(advanced_frame, text=current_ver_i18n.get('label', 'Current Version:'), bootstyle="secondary",
                              tooltip=current_ver_i18n.get('tooltip', '...'), row=self.current_row, column=0)
@@ -2279,7 +2295,15 @@ class ConfigApp:
                                            textvariable=self.overlay_engine_value)
         self.overlay_engine.grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
-        
+
+        # Scan Delay
+        scan_delay_i18n = overlay_i18n.get('scan_delay', {})
+        HoverInfoLabelWidget(overlay_frame, text=scan_delay_i18n.get('label', 'Scan Delay:'),
+                             tooltip=scan_delay_i18n.get('tooltip', 'Delay between GSM Receiving Text, and Scanning for Overlay. Increase this value if your game\'s text appears slowly.'),
+                             row=self.current_row, column=0)
+        ttk.Entry(overlay_frame, textvariable=self.scan_delay_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        self.current_row += 1
+
         # Periodic Settings
         periodic_i18n = overlay_i18n.get('periodic', {})
         HoverInfoLabelWidget(overlay_frame, text=periodic_i18n.get('label', 'Periodic:'),

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

@@ -1,5 +1,7 @@
 import asyncio
+import json
 import re
+from datetime import datetime
 
 import pyperclip
 import requests
@@ -7,12 +9,11 @@ import websockets
 from websockets import InvalidStatus
 from rapidfuzz import fuzz
 
-
+from GameSentenceMiner.util.configuration import get_config, gsm_status, logger, gsm_state
 from GameSentenceMiner.util.db import GameLinesTable
 from GameSentenceMiner.util.gsm_utils import do_text_replacements, TEXT_REPLACEMENTS_FILE, run_new_thread
-from GameSentenceMiner.util.configuration import *
-from GameSentenceMiner.util.text_log import *
 from GameSentenceMiner import obs
+from GameSentenceMiner.util.text_log import add_line, get_text_log
 from GameSentenceMiner.web.texthooking_page import add_event_to_texthooker, overlay_server_thread
 
 from GameSentenceMiner.util.get_overlay_coords import OverlayProcessor

{gamesentenceminer-2.17.0 → gamesentenceminer-2.17.2}/GameSentenceMiner/gsm.py

@@ -1,20 +1,3 @@
-import tempfile
-import time
-import asyncio
-import subprocess
-import sys
-
-import os
-import warnings
-
-import requests
-
-from GameSentenceMiner.util.get_overlay_coords import OverlayThread
-from GameSentenceMiner.util.gsm_utils import remove_html_and_cloze_tags
-
-os.environ.pop('TCL_LIBRARY', None)
-
-
 def handle_error_in_initialization(e):
     """Handle errors that occur during initialization."""
     logger.exception(e, exc_info=True)
@@ -29,9 +12,20 @@ def handle_error_in_initialization(e):
 
 
 try:
+    import asyncio
+    import os
+    import shutil
+    import subprocess
+    import sys
+    import tempfile
+    import threading
+    import time
+    import warnings
+    import requests
     import os.path
     import signal
     from subprocess import Popen
+    os.environ.pop('TCL_LIBRARY', None)
 
     import keyboard
     import ttkbootstrap as ttk
@@ -42,7 +36,12 @@ try:
     import psutil
 
     start_time = time.time()
-    from GameSentenceMiner.util.configuration import *
+    from GameSentenceMiner.util.configuration import logger, gsm_state, get_config, anki_results, AnkiUpdateResult, \
+    get_temporary_directory, get_log_path, get_master_config, switch_profile_and_save, get_app_directory, gsm_status, \
+    is_windows, is_linux
+    from GameSentenceMiner.util.get_overlay_coords import OverlayThread
+    from GameSentenceMiner.util.gsm_utils import remove_html_and_cloze_tags
+
     logger.debug(f"[Import] configuration: {time.time() - start_time:.3f}s")
 
     start_time = time.time()
@@ -113,10 +112,6 @@ try:
     logger.debug(
         f"[Import] util.text_log (GameLine, get_text_event, get_mined_line, get_all_lines, game_log): {time.time() - start_time:.3f}s")
 
-    start_time = time.time()
-    from GameSentenceMiner.util import *
-    logger.debug(f"[Import] util *: {time.time() - start_time:.3f}s")
-
     start_time = time.time()
     from GameSentenceMiner.web import texthooking_page
     logger.debug(
@@ -675,6 +670,7 @@ def initialize_async():
 
 
 def handle_websocket_message(message: Message):
+    logger.info(f"WebSocket Message Received: {message.to_json()}")
     try:
         match FunctionName(message.function):
             case FunctionName.QUIT:
@@ -683,7 +679,7 @@ def handle_websocket_message(message: Message):
             case FunctionName.QUIT_OBS:
                 close_obs()
             case FunctionName.START_OBS:
-                obs.start_obs()
+                obs.start_obs(force_restart=not gsm_status.obs_connected)
             case FunctionName.OPEN_SETTINGS:
                 open_settings()
             case FunctionName.OPEN_TEXTHOOKER:

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

@@ -165,28 +165,36 @@ class OBSConnectionManager(threading.Thread):
                 self.counter = 0
                 return
             start_replay_buffer()
-
+    
 def get_obs_path():
     return os.path.join(configuration.get_app_directory(), 'obs-studio/bin/64bit/obs64.exe')
 
 def is_process_running(pid):
     try:
         process = psutil.Process(pid)
-        return 'obs' in process.exe()
+        return 'obs' in process.exe().lower()
     except (psutil.NoSuchProcess, psutil.AccessDenied, OSError):
         if os.path.exists(OBS_PID_FILE):
             os.remove(OBS_PID_FILE)
         return False
 
-def start_obs():
+def start_obs(force_restart=False):
     global obs_process_pid
     if os.path.exists(OBS_PID_FILE):
         with open(OBS_PID_FILE, "r") as f:
             try:
                 obs_process_pid = int(f.read().strip())
                 if is_process_running(obs_process_pid):
-                    print(f"OBS is already running with PID: {obs_process_pid}")
-                    return obs_process_pid
+                    if force_restart:
+                        try:
+                            process = psutil.Process(obs_process_pid)
+                            process.terminate()
+                            process.wait(timeout=10)
+                            print("OBS process terminated for restart.")
+                        except Exception as e:
+                            print(f"Error terminating OBS process: {e}")
+                    else:
+                        return obs_process_pid
             except ValueError:
                 print("Invalid PID found in file. Launching new OBS instance.")
             except OSError:
@@ -693,5 +701,7 @@ def create_scene():
 if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO)
     connect_to_obs_sync()
-    # set_fit_to_screen_for_scene_items(get_current_scene())
-    create_scene()
+    img = get_screenshot_PIL(source_name='Display Capture 2', compression=100, img_format='jpg', width=2560, height=1440)
+    img.show()
+    # # set_fit_to_screen_for_scene_items(get_current_scene())
+    # create_scene()

{gamesentenceminer-2.17.0 → gamesentenceminer-2.17.2}/GameSentenceMiner/ocr/owocr_helper.py

@@ -19,13 +19,15 @@ from PIL import Image
 from rapidfuzz import fuzz
 
 from GameSentenceMiner import obs
-from GameSentenceMiner.util.electron_config import *
 from GameSentenceMiner.ocr.ss_picker import ScreenCropper
 from GameSentenceMiner.owocr.owocr.run import TextFiltering
 from GameSentenceMiner.util.configuration import get_config, get_app_directory, get_temporary_directory
 from GameSentenceMiner.ocr.gsm_ocr_config import OCRConfig, has_config_changed, set_dpi_awareness, get_window, get_ocr_config_path
-from GameSentenceMiner.owocr.owocr import screen_coordinate_picker, run
-from GameSentenceMiner.util.gsm_utils import sanitize_filename, do_text_replacements, OCR_REPLACEMENTS_FILE
+from GameSentenceMiner.owocr.owocr import run
+from GameSentenceMiner.util.electron_config import get_ocr_ocr2, get_ocr_send_to_clipboard, get_ocr_scan_rate, \
+    has_ocr_config_changed, reload_electron_config, get_ocr_two_pass_ocr, get_ocr_optimize_second_scan, \
+    get_ocr_language, get_ocr_manual_ocr_hotkey
+from GameSentenceMiner.util.gsm_utils import sanitize_filename
 import threading
 import time
 
@@ -173,7 +175,7 @@ class WebsocketServerThread(threading.Thread):
             self._stop_event = stop_event = asyncio.Event()
             self._event.set()
             self.server = start_server = websockets.serve(self.server_handler,
-                                                          "0.0.0.0",
+                                                          get_config().advanced.localhost_bind_address,
                                                           get_config().advanced.ocr_websocket_port,
                                                           max_size=1000000000)
             async with start_server:
@@ -420,7 +422,7 @@ def get_ocr2_image(crop_coords, og_image: Image.Image, ocr2_engine=None):
     Logic is unchanged, but code is refactored for clarity and maintainability.
     """
     def return_original_image():
-        logger.info("Returning original image for OCR2 (no cropping or optimization).")
+        logger.debug("Returning original image for OCR2 (no cropping or optimization).")
         if not crop_coords or not get_ocr_optimize_second_scan():
             return og_image
         x1, y1, x2, y2 = crop_coords
@@ -546,9 +548,10 @@ def add_ss_hotkey(ss_hotkey="ctrl+shift+g"):
         ocr_config = get_ocr_config()
         img = obs.get_screenshot_PIL(compression=80, img_format="jpg")
         ocr_config.scale_to_custom_size(img.width, img.height)
-        img = run.apply_ocr_config_to_image(img, ocr_config, is_secondary=True)
-        do_second_ocr("", datetime.now(), img, TextFiltering(lang=get_ocr_language()), ignore_furigana_filter=True, ignore_previous_result=True)
-        
+        for rectangle in [rectangle for rectangle in ocr_config.rectangles if rectangle.is_secondary]:
+            new_img = run.apply_ocr_config_to_image(img, ocr_config, is_secondary=True, rectangles=[rectangle])
+            do_second_ocr("", datetime.now(), new_img, TextFiltering(lang=get_ocr_language()), ignore_furigana_filter=True, ignore_previous_result=True)
+
     filtering = TextFiltering(lang=get_ocr_language())
     cropper = ScreenCropper()
     def capture():

{gamesentenceminer-2.17.0 → gamesentenceminer-2.17.2}/GameSentenceMiner/owocr/owocr/run.py

@@ -1,6 +1,11 @@
+import os
+import sys
+
 from GameSentenceMiner.ocr.gsm_ocr_config import set_dpi_awareness, get_scene_ocr_config
-from GameSentenceMiner.util.electron_config import *  # noqa: F403
 from GameSentenceMiner.util.gsm_utils import do_text_replacements, OCR_REPLACEMENTS_FILE
+from GameSentenceMiner.util.electron_config import get_ocr_language, get_ocr_requires_open_window, \
+    has_ocr_config_changed, reload_electron_config, get_ocr_scan_rate, get_ocr_two_pass_ocr, get_ocr_keep_newline, \
+    get_ocr_ocr1, get_furigana_filter_sensitivity
 
 try:
     import win32gui
@@ -52,7 +57,7 @@ import psutil
 from .ocr import *  # noqa: F403
 from .config import Config
 from .screen_coordinate_picker import get_screen_selection
-from GameSentenceMiner.util.configuration import get_temporary_directory
+from GameSentenceMiner.util.configuration import get_config, get_temporary_directory
 
 from skimage.metrics import structural_similarity as ssim
 from typing import Union
@@ -286,7 +291,7 @@ class WebsocketServerThread(threading.Thread):
             self._stop_event = stop_event = asyncio.Event()
             self._event.set()
             self.server = start_server = websockets.serve(
-                self.server_handler, '0.0.0.0', config.get_general('websocket_port'), max_size=1000000000)
+                self.server_handler, get_config().advanced.localhost_bind_address, config.get_general('websocket_port'), max_size=1000000000)
             async with start_server:
                 await stop_event.wait()
         asyncio.run(main())
@@ -1135,14 +1140,15 @@ def scale_down_width_height(width, height):
             return width, height
 
 
-def apply_ocr_config_to_image(img, ocr_config, is_secondary=False):
+def apply_ocr_config_to_image(img, ocr_config, is_secondary=False, rectangles=None):
     for rectangle in ocr_config.rectangles:
         if rectangle.is_excluded:
             left, top, width, height = rectangle.coordinates
             draw = ImageDraw.Draw(img)
             draw.rectangle((left, top, left + width, top + height), fill=(0, 0, 0, 0))
             
-    rectangles = [r for r in ocr_config.rectangles if not r.is_excluded and r.is_secondary == is_secondary]
+    if not rectangles:   
+        rectangles = [r for r in ocr_config.rectangles if not r.is_excluded and r.is_secondary == is_secondary]
     
     # Sort top to bottom
     if rectangles:

{gamesentenceminer-2.17.0 → gamesentenceminer-2.17.2}/GameSentenceMiner/util/configuration.py

@@ -589,9 +589,10 @@ class Advanced:
     multi_line_sentence_storage_field: str = ''
     ocr_websocket_port: int = 9002
     texthooker_communication_websocket_port: int = 55001
-    afk_timer_seconds: int = 120
-    session_gap_seconds: int = 3600
-    streak_requirement_hours: float = 0.01 # 1 second required per day to keep your streak by default
+    afk_timer_seconds: int = 120 # LEGACY, not used anymore
+    session_gap_seconds: int = 3600 # LEGACY, not used anymore
+    streak_requirement_hours: float = 0.01 # LEGACY, not used anymore
+    localhost_bind_address: str = '127.0.0.1' # Default 127.0.0.1 for security, set to 0.0.0.0 to allow external connections
 
     def __post_init__(self):
         if self.plaintext_websocket_port == -1:
@@ -646,6 +647,7 @@ class Overlay:
     monitor_to_capture: int = 0
     periodic: bool = False
     periodic_interval: float = 1.0
+    scan_delay: float = 0.25
 
     def __post_init__(self):
         if self.monitor_to_capture == -1:
@@ -1248,5 +1250,5 @@ is_dev = is_running_from_source()
 
 is_beangate = os.path.exists("C:/Users/Beangate")
 
-logger.debug(f"Running in development mode: {is_dev}")
-logger.debug(f"Running on Beangate's PC: {is_beangate}")
+# logger.debug(f"Running in development mode: {is_dev}")
+# logger.debug(f"Running on Beangate's PC: {is_beangate}")