GameSentenceMiner 2.6.4__py3-none-any.whl → 2.7.0__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -7,7 +7,7 @@ import urllib.request
 from datetime import datetime, timedelta
 from requests import post
 
-from GameSentenceMiner import obs, util, notification, ffmpeg
+from GameSentenceMiner import obs, util, notification, ffmpeg, gametext
 from GameSentenceMiner.ai.gemini import translate_with_context
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.configuration import get_config
@@ -279,7 +279,7 @@ def update_new_card():
     if use_prev_audio:
         lines = get_utility_window().get_selected_lines()
         with util.lock:
-            update_anki_card(last_card, note=get_initial_card_info(last_card, lines), reuse_audio=True)
+            update_anki_card(last_card, note=get_initial_card_info(last_card, lines), game_line=gametext.get_mined_line(last_card, lines), reuse_audio=True)
         get_utility_window().reset_checkboxes()
     else:
         logger.info("New card(s) detected! Added to Processing Queue!")

GameSentenceMiner/configuration.py

@@ -392,7 +392,9 @@ def get_app_directory():
 
 
 def get_log_path():
-    return os.path.join(get_app_directory(), 'gamesentenceminer.log')
+    path = os.path.join(get_app_directory(), "logs", 'gamesentenceminer.log')
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    return path
 
 temp_directory = ''
 

GameSentenceMiner/gametext.py

@@ -1,12 +1,13 @@
 import asyncio
+import difflib
 import re
 import threading
 import time
-from datetime import datetime
+from datetime import datetime, timedelta
 
 import pyperclip
 import websockets
-from websockets import InvalidStatusCode
+from websockets import InvalidStatus
 
 from GameSentenceMiner import util
 from GameSentenceMiner.model import AnkiCard
@@ -66,12 +67,15 @@ class GameText:
             return matches[occurrence]
         return None
 
-    def add_line(self, line_text):
-        new_line = GameLine(line_text, datetime.now(), self.values[-1] if self.values else None, None, self.game_line_index)
+    def add_line(self, line_text, line_time=None):
+        if not line_text:
+            return
+        new_line = GameLine(line_text, line_time if line_time else datetime.now(), self.values[-1] if self.values else None, None, self.game_line_index)
         self.game_line_index += 1
         if self.values:
             self.values[-1].next = new_line
         self.values.append(new_line)
+        # self.remove_old_events(datetime.now() - timedelta(minutes=10))
 
     def has_line(self, line_text) -> bool:
         for game_line in self.values:
@@ -79,6 +83,9 @@ class GameText:
                 return True
         return False
 
+    # def remove_old_events(self, cutoff_time: datetime):
+    #     self.values = [line for line in self.values if line.time >= cutoff_time]
+
 line_history = GameText()
 
 class ClipboardMonitor(threading.Thread):
@@ -111,7 +118,7 @@ class ClipboardMonitor(threading.Thread):
 async def listen_websocket():
     global current_line, current_line_time, line_history, reconnecting, websocket_connected
     try_other = False
-    websocket_url = f'ws://{get_config().general.websocket_uri}'
+    websocket_url = f'ws://{get_config().general.websocket_uri}/gsm'
     while True:
         if try_other:
             websocket_url = f'ws://{get_config().general.websocket_uri}/api/ws/text/origin'
@@ -123,6 +130,7 @@ async def listen_websocket():
                     reconnecting = False
                 websocket_connected = True
                 try_other = True
+                line_time = None
                 while True:
                     message = await websocket.recv()
                     logger.debug(message)
@@ -130,14 +138,17 @@ async def listen_websocket():
                         data = json.loads(message)
                         if "sentence" in data:
                             current_clipboard = data["sentence"]
+                        if "time" in data:
+                            line_time = datetime.fromisoformat(data["time"])
+                            print(line_time)
                     except json.JSONDecodeError or TypeError:
                         current_clipboard = message
                     if current_clipboard != current_line:
-                        handle_new_text_event(current_clipboard)
-        except (websockets.ConnectionClosed, ConnectionError, InvalidStatusCode) as e:
-            if isinstance(e, InvalidStatusCode):
-                e: InvalidStatusCode
-                if e.status_code == 404:
+                        handle_new_text_event(current_clipboard, line_time if line_time else None)
+        except (websockets.ConnectionClosed, ConnectionError, InvalidStatus) as e:
+            if isinstance(e, InvalidStatus):
+                e: InvalidStatus
+                if e.response.status_code == 404:
                     logger.info("Texthooker WebSocket connection failed. Attempting some fixes...")
                     try_other = True
 
@@ -148,7 +159,7 @@ async def listen_websocket():
             reconnecting = True
             await asyncio.sleep(5)
 
-def handle_new_text_event(current_clipboard):
+def handle_new_text_event(current_clipboard, line_time=None):
     global current_line, current_line_time, line_history, current_line_after_regex
     current_line = current_clipboard
     if get_config().general.texthook_replacement_regex:
@@ -156,9 +167,10 @@ def handle_new_text_event(current_clipboard):
     else:
         current_line_after_regex = current_line
     logger.info(f"Line Received: {current_line_after_regex}")
-    current_line_time = datetime.now()
-    line_history.add_line(current_line_after_regex)
-    get_utility_window().add_text(line_history[-1])
+    current_line_time = line_time if line_time else datetime.now()
+    line_history.add_line(current_line_after_regex, line_time)
+    if get_utility_window():
+        get_utility_window().add_text(line_history[-1])
 
 
 def reset_line_hotkey_pressed():
@@ -232,6 +244,8 @@ def get_line_and_future_lines(last_note):
 def get_mined_line(last_note: AnkiCard, lines):
     if not last_note:
         return lines[-1]
+    if not lines:
+        lines = get_all_lines()
 
     sentence = last_note.get_field(get_config().anki.sentence_field)
     for line in lines:

GameSentenceMiner/gsm.py

@@ -1,4 +1,3 @@
-
 import os.path
 import signal
 from subprocess import Popen
@@ -496,6 +495,7 @@ def cleanup():
         icon.stop()
 
     settings_window.window.destroy()
+    time.sleep(5)
     logger.info("Cleanup complete.")
 
 
@@ -594,8 +594,8 @@ def main(reloading=False):
         win32api.SetConsoleCtrlHandler(handle_exit())
 
     try:
-        if get_config().general.open_config_on_startup:
-            root.after(0, settings_window.show)
+        # if get_config().general.open_config_on_startup:
+        #     root.after(0, settings_window.show)
         if get_config().general.open_multimine_on_startup:
             root.after(0, get_utility_window().show)
         root.after(0, post_init)
@@ -614,4 +614,8 @@ def main(reloading=False):
 
 if __name__ == "__main__":
     logger.info("Starting GSM")
-    main()
+    try:
+        main()
+    except Exception as e:
+        logger.exception(e)
+        time.sleep(5)

GameSentenceMiner/obs.py

@@ -1,6 +1,7 @@
 import logging
 import os.path
 import subprocess
+import tempfile
 import time
 
 import psutil
@@ -72,20 +73,27 @@ def get_obs_websocket_config_values():
     if get_config().obs.password == 'your_password':
         logger.info("OBS WebSocket password is not set. Setting it now...")
         config = get_master_config()
-        config.get_config().obs.port = server_port
-        config.get_config().obs.password = server_password
+        config.get_scene_ocr_config().obs.port = server_port
+        config.get_scene_ocr_config().obs.password = server_password
         with open(get_config_path(), 'w') as file:
             json.dump(config.to_dict(), file, indent=4)
         reload_config()
 
 
+reconnecting = False
+
 def on_connect(obs):
+    global reconnecting
     logger.info("Reconnected to OBS WebSocket.")
-    start_replay_buffer()
+    if reconnecting:
+        start_replay_buffer()
+        reconnecting = False
 
 
 def on_disconnect(obs):
+    global reconnecting
     logger.error("OBS Connection Lost!")
+    reconnecting = True
 
 
 def connect_to_obs():
@@ -113,6 +121,7 @@ def do_obs_call(request, from_dict = None, retry=10):
         if not client:
             time.sleep(1)
             return do_obs_call(request, from_dict, retry - 1)
+        logger.debug("Sending obs call: " + str(request))
         response = client.call(request)
         if not response.status and retry > 0:
             time.sleep(1)
@@ -142,8 +151,8 @@ def toggle_replay_buffer():
 # Start replay buffer
 def start_replay_buffer(retry=5):
     try:
-        do_obs_call(requests.GetVersion())
-        do_obs_call(requests.StartReplayBuffer())
+        if not get_replay_buffer_status()['outputActive']:
+            do_obs_call(requests.StartReplayBuffer(), retry=0)
     except Exception as e:
         if "socket is already closed" in str(e):
             if retry > 0:
@@ -152,6 +161,12 @@ def start_replay_buffer(retry=5):
             else:
                 logger.error(f"Error starting replay buffer: {e}")
 
+def get_replay_buffer_status():
+    try:
+        return do_obs_call(requests.GetReplayBufferStatus())
+    except Exception as e:
+        logger.error(f"Error getting replay buffer status: {e}")
+
 
 # Stop replay buffer
 def stop_replay_buffer():
@@ -176,7 +191,7 @@ def save_replay_buffer():
 
 def get_current_scene():
     try:
-        return do_obs_call(requests.GetCurrentProgramScene(), SceneInfo.from_dict).sceneName
+        return do_obs_call(requests.GetCurrentProgramScene(), SceneInfo.from_dict, retry=0).sceneName
     except Exception as e:
         logger.error(f"Couldn't get scene: {e}")
     return ''
@@ -197,7 +212,7 @@ def get_record_directory():
         return ''
 
 
-def get_screenshot():
+def get_screenshot(compression=-1):
     try:
         screenshot = util.make_unique_file_name(os.path.abspath(
             configuration.get_temporary_directory()) + '/screenshot.png')
@@ -207,11 +222,29 @@ def get_screenshot():
         if not current_source_name:
             logger.error("No active scene found.")
             return
-        do_obs_call(requests.SaveSourceScreenshot(sourceName=current_source_name, imageFormat='png', imageFilePath=screenshot))
+        start = time.time()
+        logger.debug(f"Current source name: {current_source_name}")
+        response = client.call(requests.SaveSourceScreenshot(sourceName=current_source_name, imageFormat='png', imageFilePath=screenshot, imageCompressionQuality=compression))
+        logger.debug(f"Screenshot response: {response}")
+        logger.debug(f"Screenshot took {time.time() - start:.3f} seconds to save")
         return screenshot
     except Exception as e:
         logger.error(f"Error getting screenshot: {e}")
 
+def get_screenshot_base64():
+    try:
+        update_current_game()
+        current_source = get_source_from_scene(get_current_game())
+        current_source_name = current_source.sourceName
+        if not current_source_name:
+            logger.error("No active scene found.")
+            return
+        response = do_obs_call(requests.GetSourceScreenshot(sourceName=current_source_name, imageFormat='png', imageCompressionQuality=0))
+        with open('screenshot_response.txt', 'wb') as f:
+            f.write(str(response).encode())
+        return response['imageData']
+    except Exception as e:
+        logger.error(f"Error getting screenshot: {e}")
 
 def update_current_game():
     configuration.current_game = get_current_scene()

GameSentenceMiner/ocr/ocrconfig.py

@@ -0,0 +1,130 @@
+import configparser
+import os
+import re
+
+class OCRConfig:
+    def __init__(self, config_file=os.path.expanduser("~/.config/owocr_config.ini")):
+        self.config_file = config_file
+        self.config = configparser.ConfigParser(allow_no_value=True)
+        self.raw_config = {}  # Store the raw lines of the config file
+        self.load_config()
+
+    def load_config(self):
+        if os.path.exists(self.config_file):
+            self.raw_config = self._read_config_with_comments()
+            self.config.read_dict(self._parse_config_to_dict())
+        else:
+            self.create_default_config()
+
+    def create_default_config(self):
+        self.raw_config = {
+            "general": [
+                ";engines = avision,alivetext,bing,glens,glensweb,gvision,azure,mangaocr,winrtocr,oneocr,easyocr,rapidocr,ocrspace",
+                ";engine = glens",
+                "read_from = screencapture",
+                "write_to = websocket",
+                ";note: this specifies an amount of seconds to wait for auto pausing the program after a successful text recognition. Will be ignored when reading with screen capture. 0 to disable.",
+                ";auto_pause = 0",
+                ";pause_at_startup = False",
+                ";logger_format = <green>{time:HH:mm:ss.SSS}</green> | <level>{message}</level>",
+                ";engine_color = cyan",
+                "websocket_port = 7331",
+                ";delay_secs = 0.5",
+                ";notifications = False",
+                ";ignore_flag = False",
+                ";delete_images = False",
+                ";note: this specifies a combo to wait on for pausing the program. As an example: <ctrl>+<shift>+p. The list of keys can be found here: https://pynput.readthedocs.io/en/latest/keyboard.html#pynput.keyboard.Key",
+                ";combo_pause = <ctrl>+<shift>+p",
+                ";note: this specifies a combo to wait on for switching the OCR engine. As an example: <ctrl>+<shift>+a. To be used with combo_pause. The list of keys can be found here: https://pynput.readthedocs.io/en/latest/keyboard.html#pynput.keyboard.Key",
+                ";combo_engine_switch = <ctrl>+<shift>+a",
+                ";note: screen_capture_area can be empty for the coordinate picker, \"screen_N\" (where N is the screen number starting from 1) for an entire screen, have a manual set of coordinates (x,y,width,height) or a window name (the first matching window title will be used).",
+                ";screen_capture_area = ",
+                ";screen_capture_area = screen_1",
+                ";screen_capture_area = 400,200,1500,600",
+                ";screen_capture_area = OBS",
+                ";note: if screen_capture_area is a window name, this can be changed to capture inactive windows too.",
+                ";screen_capture_only_active_windows = True",
+                ";screen_capture_delay_secs = 3",
+                ";note: this specifies a combo to wait on for taking a screenshot instead of using the delay. As an example: <ctrl>+<shift>+s. The list of keys can be found here: https://pynput.readthedocs.io/en/latest/keyboard.html#pynput.keyboard.Key",
+                ";screen_capture_combo = <ctrl>+<shift>+s",
+            ],
+            "winrtocr": [";url = http://aaa.xxx.yyy.zzz:8000"],
+            "oneocr": [";url = http://aaa.xxx.yyy.zzz:8001"],
+            "azure": [";api_key = api_key_here", ";endpoint = https://YOURPROJECT.cognitiveservices.azure.com/"],
+            "mangaocr": ["pretrained_model_name_or_path = kha-white/manga-ocr-base", "force_cpu = False"],
+            "easyocr": ["gpu = True"],
+            "ocrspace": [";api_key = api_key_here"],
+        }
+        self.config.read_dict(self._parse_config_to_dict())
+        self.save_config()
+
+    def _read_config_with_comments(self):
+        with open(self.config_file, "r") as f:
+            lines = f.readlines()
+        config_data = {}
+        current_section = None
+        for line in lines:
+            line = line.strip()
+            if line.startswith("[") and line.endswith("]"):
+                current_section = line[1:-1]
+                config_data[current_section] = []
+            elif current_section is not None:
+                config_data[current_section].append(line)
+        return config_data
+
+    def _parse_config_to_dict(self):
+        parsed_config = {}
+        for section, lines in self.raw_config.items():
+            parsed_config[section] = {}
+            for line in lines:
+                if "=" in line and not line.startswith(";"):
+                    key, value = line.split("=", 1)
+                    parsed_config[section][key.strip()] = value.strip()
+        return parsed_config
+
+    def save_config(self):
+        with open(self.config_file, "w") as f:
+            for section, lines in self.raw_config.items():
+                f.write(f"[{section}]\n")
+                for line in lines:
+                    f.write(f"{line}\n")
+
+    def get_value(self, section, key):
+        if section in self.config and key in self.config[section]:
+            return self.config[section][key]
+        return None
+
+    def set_value(self, section, key, value):
+        if section not in self.config:
+            self.raw_config[section] = [] #add section if it does not exist.
+        if section not in self.config:
+            self.config[section] = {}
+        self.config[section][key] = str(value)
+
+        # Update the raw config to keep comments
+        found = False
+        for i, line in enumerate(self.raw_config[section]):
+            if line.startswith(key + " ="):
+                self.raw_config[section][i] = f"{key} = {value}"
+                found = True
+                break
+        if not found:
+            self.raw_config[section].append(f"{key} = {value}")
+
+        self.save_config()
+
+    def get_section(self, section):
+        if section in self.config:
+            return dict(self.config[section])
+        return None
+
+    def set_screen_capture_area(self, screen_capture_data):
+        if not isinstance(screen_capture_data, dict) or "coordinates" not in screen_capture_data:
+            raise ValueError("Invalid screen capture data format.")
+
+        coordinates = screen_capture_data["coordinates"]
+        if len(coordinates) != 4:
+            raise ValueError("Coordinates must contain four values: x, y, width, height.")
+
+        x, y, width, height = coordinates
+        self.set_value("general", "screen_capture_area", f"{x},{y},{width},{height}")