GameSentenceMiner 2.17.1__tar.gz → 2.17.2__tar.gz

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

@@ -558,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.1 → gamesentenceminer-2.17.2}/GameSentenceMiner/config_gui.py

@@ -384,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)
@@ -407,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)
@@ -621,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(),
@@ -643,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(),
             )
@@ -1998,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)
@@ -2285,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.1 → gamesentenceminer-2.17.2}/GameSentenceMiner/gsm.py

@@ -1,21 +1,3 @@
-import asyncio
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-import threading
-import time
-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)
@@ -30,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
@@ -46,6 +39,8 @@ try:
     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")
 

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

@@ -701,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.1 → gamesentenceminer-2.17.2}/GameSentenceMiner/ocr/owocr_helper.py

@@ -175,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:

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

@@ -57,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
@@ -291,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())

{gamesentenceminer-2.17.1 → 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}")

{gamesentenceminer-2.17.1 → gamesentenceminer-2.17.2}/GameSentenceMiner/util/db.py

@@ -264,6 +264,50 @@ class SQLiteDBTable:
     @classmethod
     def drop(cls):
         cls._db.execute(f"DROP TABLE IF EXISTS {cls._table}", commit=True)
+        
+    @classmethod
+    def has_column(cls, column_name: str) -> bool:
+        row = cls._db.fetchone(
+            f"PRAGMA table_info({cls._table})")
+        if not row:
+            return False
+        columns = [col[1] for col in cls._db.fetchall(
+            f"PRAGMA table_info({cls._table})")]
+        return column_name in columns
+    
+    @classmethod
+    def rename_column(cls, old_column: str, new_column: str):
+        cls._db.execute(
+            f"ALTER TABLE {cls._table} RENAME COLUMN {old_column} TO {new_column}", commit=True)
+        
+    @classmethod
+    def drop_column(cls, column_name: str):
+        cls._db.execute(
+            f"ALTER TABLE {cls._table} DROP COLUMN {column_name}", commit=True)
+        
+    @classmethod
+    def get_column_type(cls, column_name: str) -> Optional[str]:
+        row = cls._db.fetchone(
+            f"PRAGMA table_info({cls._table})")
+        if not row:
+            return None
+        columns = cls._db.fetchall(
+            f"PRAGMA table_info({cls._table})")
+        for col in columns:
+            if col[1] == column_name:
+                return col[2]  # Return the type
+        return None
+        
+    @classmethod
+    def alter_column_type(cls, old_column: str, new_column: str, new_type: str):
+        # Add new column
+        cls._db.execute(
+            f"ALTER TABLE {cls._table} ADD COLUMN {new_column} {new_type}", commit=True)
+        # Copy and cast data
+        cls._db.execute(
+            f"UPDATE {cls._table} SET {new_column} = CAST({old_column} AS {new_type})", commit=True)
+        cls._db.execute(
+            f"ALTER TABLE {cls._table} DROP COLUMN {old_column}", commit=True)
 
 
 class AIModelsTable(SQLiteDBTable):
@@ -333,10 +377,10 @@ class AIModelsTable(SQLiteDBTable):
 
 class GameLinesTable(SQLiteDBTable):
     _table = 'game_lines'
-    _fields = ['game_name', 'line_text', 'timestamp', 'screenshot_in_anki',
-               'audio_in_anki', 'screenshot_path', 'audio_path', 'replay_path', 'translation']
+    _fields = ['game_name', 'line_text', 'screenshot_in_anki',
+               'audio_in_anki', 'screenshot_path', 'audio_path', 'replay_path', 'translation', 'timestamp']
     _types = [str,  # Includes primary key type
-              str, str, str, str, str, str, str, str, str]
+              str, str, str, str, str, str, str, str, float]
     _pk = 'id'
     _auto_increment = False  # Use string IDs
 
@@ -355,7 +399,7 @@ class GameLinesTable(SQLiteDBTable):
         self.game_name = game_name
         self.line_text = line_text
         self.context = context
-        self.timestamp = timestamp if timestamp is not None else datetime.now().timestamp()
+        self.timestamp = float(timestamp) if timestamp is not None else datetime.now().timestamp()
         self.screenshot_in_anki = screenshot_in_anki if screenshot_in_anki is not None else ''
         self.audio_in_anki = audio_in_anki if audio_in_anki is not None else ''
         self.screenshot_path = screenshot_path if screenshot_path is not None else ''
@@ -416,9 +460,79 @@ class GameLinesTable(SQLiteDBTable):
             params,
             commit=True
         )
+        
+    @classmethod
+    def get_lines_filtered_by_timestamp(cls, start: Optional[float] = None, end: Optional[float] = None) -> List['GameLinesTable']:
+        """
+        Fetches all lines optionally filtered by start and end timestamps.
+        If start or end is None, that bound is ignored.
+        """
+        query = f"SELECT * FROM {cls._table}"
+        conditions = []
+        params = []
+
+        # Add timestamp conditions if provided
+        if start is not None:
+            conditions.append("timestamp >= ?")
+            params.append(start)
+        if end is not None:
+            conditions.append("timestamp <= ?")
+            params.append(end)
+
+        # Combine conditions into WHERE clause if any
+        if conditions:
+            query += " WHERE " + " AND ".join(conditions)
+
+        # Sort by timestamp ascending
+        query += " ORDER BY timestamp ASC"
+
+        # Execute the query
+        rows = cls._db.fetchall(query, tuple(params))
+        return [cls.from_row(row) for row in rows]
+        
+class StatsRollupTable(SQLiteDBTable):
+    _table = 'stats_rollup'
+    _fields = ['date', 'games_played', 'lines_mined', 'anki_cards_created', 'time_spent_mining']
+    _types = [int,  # Includes primary key type
+              str, int, int, int, float]
+    _pk = 'id'
+    _auto_increment = True  # Use auto-incrementing integer IDs
+    
+    def __init__(self, id: Optional[int] = None,
+                 date: Optional[str] = None,
+                 games_played: int = 0,
+                 lines_mined: int = 0,
+                 anki_cards_created: int = 0,
+                 time_spent_mining: float = 0.0):
+        self.id = id
+        self.date = date if date is not None else datetime.now().strftime("%Y-%m-%d")
+        self.games_played = games_played
+        self.lines_mined = lines_mined
+        self.anki_cards_created = anki_cards_created
+        self.time_spent_mining = time_spent_mining
 
+    @classmethod
+    def get_stats_for_date(cls, date: str) -> Optional['StatsRollupTable']:
+        row = cls._db.fetchone(
+            f"SELECT * FROM {cls._table} WHERE date=?", (date,))
+        return cls.from_row(row) if row else None
 
-def get_db_directory():
+    @classmethod
+    def update_stats(cls, date: str, games_played: int = 0, lines_mined: int = 0, anki_cards_created: int = 0, time_spent_mining: float = 0.0):
+        stats = cls.get_stats_for_date(date)
+        if not stats:
+            new_stats = cls(date=date, games_played=games_played,
+                            lines_mined=lines_mined, anki_cards_created=anki_cards_created, time_spent_mining=time_spent_mining)
+            new_stats.save()
+            return
+        stats.games_played += games_played
+        stats.lines_mined += lines_mined
+        stats.anki_cards_created += anki_cards_created
+        stats.time_spent_mining += time_spent_mining
+        stats.save()
+        
+# Ensure database directory exists and return path
+def get_db_directory(test=False, delete_test=False) -> str:
     if platform == 'win32':  # Windows
         appdata_dir = os.getenv('APPDATA')
     else:  # macOS and Linux
@@ -426,7 +540,11 @@ def get_db_directory():
     config_dir = os.path.join(appdata_dir, 'GameSentenceMiner')
     # Create the directory if it doesn't exist
     os.makedirs(config_dir, exist_ok=True)
-    return os.path.join(config_dir, 'gsm.db')
+    path = os.path.join(config_dir, 'gsm.db' if not test else 'gsm_test.db')
+    if test and delete_test:
+        if os.path.exists(path):
+            os.remove(path)
+    return path
 
 
 # Backup and compress the database on load, with today's date, up to 5 days ago (clean up old backups)
@@ -462,6 +580,8 @@ db_path = get_db_directory()
 if os.path.exists(db_path):
     backup_db(db_path)
 
+# db_path = get_db_directory(test=True, delete_test=False)
+
 gsm_db = SQLiteDB(db_path)
 
 for cls in [AIModelsTable, GameLinesTable]:
@@ -470,13 +590,47 @@ for cls in [AIModelsTable, GameLinesTable]:
     # cls.drop()
     # cls.set_db(gsm_db)  # --- IGNORE ---
     
+# GameLinesTable.drop_column('timestamp')
+    
+# if GameLinesTable.has_column('timestamp_old'):
+#     GameLinesTable.alter_column_type('timestamp_old', 'timestamp', 'TEXT')
+#     logger.info("Altered 'timestamp_old' column to 'timestamp' with TEXT type in GameLinesTable.")
+
+def check_and_run_migrations():
+    def migrate_timestamp():
+        if GameLinesTable.has_column('timestamp') and GameLinesTable.get_column_type('timestamp') != 'REAL':
+            logger.info("Migrating 'timestamp' column to REAL type in GameLinesTable.")
+            # Rename 'timestamp' to 'timestamp_old'
+            GameLinesTable.rename_column('timestamp', 'timestamp_old')
+            # Copy and cast data from old column to new column
+            GameLinesTable.alter_column_type('timestamp_old', 'timestamp', 'REAL')
+            logger.info("Migrated 'timestamp' column to REAL type in GameLinesTable.")
+            
+            
+    migrate_timestamp()
+        
+check_and_run_migrations()
+    
+# all_lines = GameLinesTable.all()
+
+
+# # Convert String timestamp to float timestamp
+# for line in all_lines:
+#     if isinstance(line.timestamp, str):
+#         try:
+#             line.timestamp = float(line.timestamp)
+#         except ValueError:
+#             # Handle invalid timestamp format
+#             line.timestamp = 0.0
+#     line.save()
+
 # import random
 # import uuid
 # from datetime import datetime
 # from GameSentenceMiner.util.text_log import GameLine
 # from GameSentenceMiner.util.db import GameLinesTable
 
-# List of common Japanese characters (kanji, hiragana, katakana)
+# # List of common Japanese characters (kanji, hiragana, katakana)
 # japanese_chars = (
 #     "あいうえおかきくけこさしすせそたちつてとなにぬねのはひふへほまみむめもやゆよらりるれろわをん"
 #     "アイウエオカキクケコサシスセソタチツテトナニヌネノハヒフヘホマミムメモヤユヨラリルレロワヲン"
@@ -513,6 +667,7 @@ for cls in [AIModelsTable, GameLinesTable]:
     
 #     if len(lines_batch) >= batch_size:
 #         GameLinesTable.add_lines(lines_batch)
+#         GameLinesTable2.add_lines(lines_batch)
 #         lines_batch = []
 #     if i % 1000 == 0:
 #         print(f"Inserted {i} lines...")
@@ -520,5 +675,18 @@ for cls in [AIModelsTable, GameLinesTable]:
 # # Insert any remaining lines
 # if lines_batch:
 #     GameLinesTable.add_lines(lines_batch)
+#     GameLinesTable2.add_lines(lines_batch)
+# for _ in range(10):  # Run multiple times to see consistent timing
+#     start_time = time.time()
+#     GameLinesTable.all()
+#     end_time = time.time()
+
+#     print(f"Time taken to query all lines from GameLinesTable: {end_time - start_time:.2f} seconds")
+
+#     start_time = time.time()
+#     GameLinesTable2.all()
+#     end_time = time.time()
+
+#     print(f"Time taken to query all lines from GameLinesTable2: {end_time - start_time:.2f} seconds")
 
-print("Done populating GameLinesDB with random Japanese text.")
+# print("Done populating GameLinesTable and GameLinesTable2 with random Japanese text.")

{gamesentenceminer-2.17.1 → gamesentenceminer-2.17.2}/GameSentenceMiner/util/downloader/download_tools.py

@@ -71,6 +71,7 @@ def download_obs_if_needed():
     def get_windows_obs_url():
         machine = platform.machine().lower()
         if machine in ['arm64', 'aarch64']:
+            logger.info("Detected Windows on ARM64. Getting ARM64 version of OBS Studio.")
             return next(asset['browser_download_url'] for asset in latest_release['assets'] if
                         asset['name'].endswith('Windows-arm64.zip'))
         return next(asset['browser_download_url'] for asset in latest_release['assets'] if 
@@ -80,12 +81,12 @@ def download_obs_if_needed():
     with urllib.request.urlopen(latest_release_url) as response:
         latest_release = json.load(response)
         obs_url = {
-            "Windows": get_windows_obs_url(),
-            "Linux": next(asset['browser_download_url'] for asset in latest_release['assets'] if
-                          asset['name'].endswith('Ubuntu-24.04-x86_64.deb')),
-            "Darwin": next(asset['browser_download_url'] for asset in latest_release['assets'] if
-                           asset['name'].endswith('macOS-Intel.dmg'))
-        }.get(platform.system(), None)
+            "Windows": get_windows_obs_url,
+            # "Linux": lambda: next(asset['browser_download_url'] for asset in latest_release['assets'] if
+            #                       asset['name'].endswith('Ubuntu-24.04-x86_64.deb')),
+            # "Darwin": lambda: next(asset['browser_download_url'] for asset in latest_release['assets'] if
+            #                        asset['name'].endswith('macOS-Intel.dmg'))
+        }.get(platform.system(), lambda: None)()
 
     if obs_url is None:
         logger.error("Unsupported OS. Please install OBS manually.")
@@ -163,43 +164,75 @@ def download_ffmpeg_if_needed():
         logger.info("FFmpeg directory exists but executables are missing. Re-downloading FFmpeg...")
         shutil.rmtree(ffmpeg_dir)
 
-    ffmpeg_url = {
-        "Windows": "https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip",
-        "Linux": "https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz",
-        "Darwin": "https://evermeet.cx/ffmpeg/ffmpeg.zip"
-    }.get(platform.system(), None)
+    system = platform.system()
+    ffmpeg_url = None
+    compressed_format = "zip"
+    if system == "Windows":
+        machine = platform.machine().lower()
+        if machine in ['arm64', 'aarch64']:
+            ffmpeg_url = "https://gsm.beangate.us/ffmpeg-8.0-essentials-shared-win-arm64.zip"
+            compressed_format = "zip"
+        else:
+            ffmpeg_url = "https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip"
+            compressed_format = "zip"
+    # elif system == "Linux":
+    #     ffmpeg_url = "https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz"
+    # elif system == "Darwin":
+    #     ffmpeg_url = "https://evermeet.cx/ffmpeg/ffmpeg.zip"
 
     if ffmpeg_url is None:
-        logger.error("Unsupported OS. Please install FFmpeg manually.")
+        logger.error("Unsupported OS/architecture. Please install FFmpeg manually.")
         return
 
     download_dir = os.path.join(get_app_directory(), "downloads")
     os.makedirs(download_dir, exist_ok=True)
-    ffmpeg_archive = os.path.join(download_dir, "ffmpeg.zip")
+    ffmpeg_archive = os.path.join(download_dir, f"ffmpeg.{compressed_format}")
 
     logger.info(f"Downloading FFmpeg from {ffmpeg_url}...")
     urllib.request.urlretrieve(ffmpeg_url, ffmpeg_archive)
     logger.info(f"FFmpeg downloaded. Extracting to {ffmpeg_dir}...")
 
     os.makedirs(ffmpeg_dir, exist_ok=True)
-
-    with zipfile.ZipFile(ffmpeg_archive, 'r') as zip_ref:
-        for member in zip_ref.namelist():
-            filename = os.path.basename(member)
-            if filename:  # Skip directories
-                source = zip_ref.open(member)
-                target = open(os.path.join(ffmpeg_dir, filename), "wb")
-                with source, target:
-                    shutil.copyfileobj(source, target)
+    
+    # Extract 7z
+    # Extract archive
+    if ffmpeg_url.endswith('.7z'):
+        with py7zr.SevenZipFile(ffmpeg_archive, mode='r') as z:
+            z.extractall(ffmpeg_dir)
+    else:
+        with zipfile.ZipFile(ffmpeg_archive, 'r') as zip_ref:
+            zip_ref.extractall(ffmpeg_dir)
+    
+    # Flatten directory structure - move all files to root ffmpeg_dir
+    def flatten_directory(directory):
+        for root, dirs, files in os.walk(directory):
+            for file in files:
+                file_path = os.path.join(root, file)
+                if root != directory:  # Only move files from subdirectories
+                    target_path = os.path.join(directory, file)
+                    # Handle name conflicts by keeping the first occurrence
+                    if not os.path.exists(target_path):
+                        shutil.move(file_path, target_path)
+        # Remove empty subdirectories
+        for root, dirs, files in os.walk(directory, topdown=False):
+            for dir_name in dirs:
+                dir_path = os.path.join(root, dir_name)
+                try:
+                    os.rmdir(dir_path)
+                except OSError:
+                    pass  # Directory not empty
+    
+    flatten_directory(ffmpeg_dir)
                     
     # Copy ffmpeg.exe to the python folder
     if os.path.exists(ffmpeg_exe_path):
         shutil.copy2(ffmpeg_exe_path, ffmpeg_in_python)
         logger.info(f"Copied ffmpeg.exe to Python folder: {ffmpeg_in_python}")
     else:
-        logger.warning(f"ffmpeg.exe not found in {ffmpeg_dir}.")
+        logger.warning(f"ffmpeg.exe not found in {ffmpeg_dir}. Extraction might have failed.")
     logger.info(f"FFmpeg extracted to {ffmpeg_dir}.")
 
+
 def download_ocenaudio_if_needed():
     ocenaudio_dir = os.path.join(get_app_directory(), 'ocenaudio')
     ocenaudio_exe_path = os.path.join(ocenaudio_dir, 'ocenaudio.exe')
@@ -234,4 +267,4 @@ def main():
     download_ocenaudio_if_needed()
 
 if __name__ == "__main__":
-    main()
+    main()

{gamesentenceminer-2.17.1 → gamesentenceminer-2.17.2}/GameSentenceMiner/util/get_overlay_coords.py

@@ -283,6 +283,9 @@ class OverlayProcessor:
         if not self.lens:
             logger.error("OCR engines are not initialized. Cannot perform OCR for Overlay.")
             return []
+        
+        if get_config().overlay.scan_delay > 0:
+            await asyncio.sleep(get_config().overlay.scan_delay)
 
         # 1. Get screenshot
         full_screenshot, monitor_width, monitor_height = self._get_full_screenshot()