GameSentenceMiner 2.9.2__py3-none-any.whl → 2.9.4__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -82,6 +82,8 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
         for key, value in get_config().anki.anki_custom_fields.items():
             note['fields'][key] = str(value)
 
+
+    notification.open_browser_window(1)
     invoke("updateNoteFields", note=note)
     tags = []
     if get_config().anki.custom_tags:
@@ -94,9 +96,11 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
     logger.info(f"UPDATED ANKI CARD FOR {last_note.noteId}")
     if get_config().features.notify_on_update:
         notification.send_note_updated(tango)
+    notification.open_browser_window(last_note.noteId)
     if get_config().features.open_anki_edit:
         notification.open_anki_card(last_note.noteId)
 
+
     if get_config().audio.external_tool and get_config().audio.external_tool_enabled and update_audio:
         open_audio_in_external(f"{get_config().audio.anki_media_collection}/{audio_in_anki}")
 

GameSentenceMiner/configuration.py

@@ -39,6 +39,13 @@ DEFAULT_CONFIG = 'Default'
 
 current_game = ''
 
+def is_linux():
+    return platform == 'linux'
+
+
+def is_windows():
+    return platform == 'win32'
+
 
 class Language(Enum):
     JAPANESE = "ja"
@@ -153,7 +160,7 @@ class Audio:
     extension: str = 'opus'
     beginning_offset: float = 0.0
     end_offset: float = 0.5
-    ffmpeg_reencode_options: str = '-c:a libopus -f opus -af \"afade=t=in:d=0.10\"'
+    ffmpeg_reencode_options: str = '-c:a libopus -f opus -af \"afade=t=in:d=0.10\"' if is_windows() else ''
     external_tool: str = ""
     anki_media_collection: str = ""
     external_tool_enabled: bool = True
@@ -619,7 +626,7 @@ console_handler.setFormatter(formatter)
 logger.addHandler(console_handler)
 
 # Create rotating file handler with level DEBUG
-if 'gsm' in sys.argv[0]:
+if 'gsm' in sys.argv[0].lower() or 'gamesentenceminer' in sys.argv[0].lower():
     file_handler = RotatingFileHandler(get_log_path(), maxBytes=1024 * 1024, backupCount=5, encoding='utf-8')
     file_handler.setLevel(logging.DEBUG)
     file_handler.setFormatter(formatter)
@@ -637,5 +644,4 @@ class GsmAppState:
         self.previous_screenshot = None
         self.previous_replay = None
 
-gsm_state = GsmAppState()
-
+gsm_state = GsmAppState()

GameSentenceMiner/ffmpeg.py

@@ -1,6 +1,7 @@
 import shutil
 import tempfile
 
+import GameSentenceMiner.configuration
 from GameSentenceMiner import obs, util, configuration
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.text_log import initial_time
@@ -8,10 +9,10 @@ from GameSentenceMiner.util import *
 
 
 def get_ffmpeg_path():
-    return os.path.join(get_app_directory(), "ffmpeg", "ffmpeg.exe") if util.is_windows() else "ffmpeg"
+    return os.path.join(get_app_directory(), "ffmpeg", "ffmpeg.exe") if is_windows() else "ffmpeg"
 
 def get_ffprobe_path():
-    return os.path.join(get_app_directory(), "ffmpeg", "ffprobe.exe") if util.is_windows() else "ffprobe"
+    return os.path.join(get_app_directory(), "ffmpeg", "ffprobe.exe") if is_windows() else "ffprobe"
 
 ffmpeg_base_command_list = [get_ffmpeg_path(), "-hide_banner", "-loglevel", "error", '-nostdin']
 
@@ -398,7 +399,7 @@ def convert_audio_to_wav(input_audio, output_wav):
         "-i", input_audio,
         "-ar", "16000",  # Resample to 16kHz
         "-ac", "1",      # Convert to mono
-        "-af", "afftdn,dialoguenhance" if not util.is_linux() else "afftdn",
+        "-af", "afftdn,dialoguenhance" if not is_linux() else "afftdn",
         output_wav
     ]
     logger.debug(" ".join(command))

GameSentenceMiner/gsm.py

@@ -1,5 +1,4 @@
 import asyncio
-import shutil
 import sys
 
 from GameSentenceMiner.vad.result import VADResult
@@ -39,7 +38,7 @@ try:
     from GameSentenceMiner.web import texthooking_page
     from GameSentenceMiner.web.texthooking_page import run_text_hooker_page
 except Exception as e:
-    from GameSentenceMiner.configuration import logger
+    from GameSentenceMiner.configuration import logger, is_linux, is_windows
     import time
     logger.info("Something bad happened during import/initialization, closing in 5 seconds")
     logger.exception(e)
@@ -74,7 +73,6 @@ class VideoToAudioHandler(FileSystemEventHandler):
 
     def process_replay(self, video_path):
         vad_trimmed_audio = ''
-        print(video_path)
         if "previous.mkv" in video_path:
             os.remove(video_path)
             video_path = gsm_state.previous_replay
@@ -682,7 +680,7 @@ async def register_scene_switcher_callback():
 
     await obs.register_scene_change_callback(scene_switcher_callback)
 
-async def main(reloading=False):
+async def async_main(reloading=False):
     global root, settings_window
     initialize(reloading)
     logger.info("Script started.")
@@ -721,11 +719,14 @@ async def main(reloading=False):
     except Exception as e:
         logger.error(f"Error stopping observer: {e}")
 
+def main():
+    asyncio.run(async_main())
+
 
 if __name__ == "__main__":
     logger.info("Starting GSM")
     try:
-        asyncio.run(main())
+        asyncio.run(async_main())
     except Exception as e:
         logger.exception(e)
         time.sleep(5)

GameSentenceMiner/notification.py

@@ -2,14 +2,11 @@ import platform
 
 import requests
 from plyer import notification
-
-from GameSentenceMiner.util import is_windows
+from GameSentenceMiner.configuration import logger, is_windows
 
 if is_windows():
     from win10toast import ToastNotifier
 
-from GameSentenceMiner.configuration import logger
-
 if is_windows():
     class MyToastNotifier(ToastNotifier):
         def __init__(self):
@@ -24,6 +21,27 @@ if is_windows():
 else:
     notifier = notification
 
+def open_browser_window(note_id):
+    url = "http://localhost:8765"
+    headers = {'Content-Type': 'application/json'}
+
+    data = {
+        "action": "guiBrowse",
+        "version": 6,
+        "params": {
+            "query": f"nid:{note_id}"
+        }
+    }
+
+    try:
+        response = requests.post(url, json=data, headers=headers)
+        if response.status_code == 200:
+            logger.info(f"Opened Anki note with ID {note_id}")
+        else:
+            logger.error(f"Failed to open Anki note with ID {note_id}")
+    except Exception as e:
+        logger.info(f"Error connecting to AnkiConnect: {e}")
+
 
 def open_anki_card(note_id):
     url = "http://localhost:8765"

GameSentenceMiner/obs.py

@@ -1,5 +1,4 @@
 import asyncio
-import logging
 import os.path
 import subprocess
 import threading
@@ -8,6 +7,7 @@ import psutil
 
 import obsws_python as obs
 
+import GameSentenceMiner.configuration
 from GameSentenceMiner import util, configuration
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.model import *
@@ -140,7 +140,7 @@ async def connect_to_obs(retry_count=0):
     if not get_config().obs.enabled:
         return
 
-    if util.is_windows():
+    if GameSentenceMiner.configuration.is_windows():
         get_obs_websocket_config_values()
 
     while True:
@@ -174,7 +174,7 @@ def connect_to_obs_sync(retry_count=0):
     if not get_config().obs.enabled or client:
         return
 
-    if util.is_windows():
+    if GameSentenceMiner.configuration.is_windows():
         get_obs_websocket_config_values()
 
     while True:

GameSentenceMiner/package.py

@@ -6,7 +6,6 @@ import requests
 from GameSentenceMiner.configuration import logger, get_app_directory
 
 PACKAGE_NAME = "GameSentenceMiner"
-VERSION_FILE_PATH = os.path.join(get_app_directory(), 'version.txt')
 
 def get_current_version():
     try:

GameSentenceMiner/util.py

@@ -7,7 +7,6 @@ import subprocess
 import threading
 import time
 from datetime import datetime
-from sys import platform
 
 from rapidfuzz import process
 
@@ -131,12 +130,6 @@ def run_agent_and_hook(pname, agent_script):
     keep_running = False
 
 
-def is_linux():
-    return platform == 'linux'
-
-def is_windows():
-    return platform == 'win32'
-
 # def run_command(command, shell=False, input=None, capture_output=False, timeout=None, check=False, **kwargs):
 #     # Use shell=True if the OS is Linux, otherwise shell=False
 #     if is_linux():
@@ -258,8 +251,6 @@ TEXT_REPLACEMENTS_FILE = os.path.join(get_app_directory(), 'config', 'text_repla
 OCR_REPLACEMENTS_FILE = os.path.join(get_app_directory(), 'config', 'ocr_replacements.json')
 os.makedirs(os.path.dirname(TEXT_REPLACEMENTS_FILE), exist_ok=True)
 
-import urllib.request
-
 # if not os.path.exists(OCR_REPLACEMENTS_FILE):
 #     url = "https://raw.githubusercontent.com/bpwhelan/GameSentenceMiner/refs/heads/main/electron-src/assets/ocr_replacements.json"
 #     try:

GameSentenceMiner/web/texthooking_page.py

@@ -247,7 +247,7 @@ def clear_history():
 
 async def add_event_to_texthooker(line: GameLine):
     new_event = event_manager.add_gameline(line)
-    await broadcast_message({
+    await websocket_server_thread.send_text({
         'event': 'text_received',
         'sentence': line.text,
         'data': new_event.to_serializable()
@@ -294,37 +294,6 @@ def play_audio():
     return jsonify({}), 200
 
 
-connected_clients = set()
-
-async def websocket_handler(websocket):
-    logger.debug(f"Client connected: {websocket.remote_address}")
-    connected_clients.add(websocket)
-    try:
-        async for message in websocket:
-            try:
-                data = json.loads(message)
-                if 'type' in data and data['type'] == 'get_events':
-                    initial_events = [{'id': 1, 'text': 'Initial event from WebSocket'}, {'id': 2, 'text': 'Another initial event'}]
-                    await websocket.send(json.dumps({'event': 'initial_events', 'payload': initial_events}))
-                elif 'update_checkbox' in data:
-                    print(f"Received checkbox update: {data}")
-                    # Handle checkbox update logic
-                    pass
-                await websocket.send(json.dumps({'response': f'Server received: {message}'}))
-            except json.JSONDecodeError:
-                await websocket.send(json.dumps({'error': 'Invalid JSON format'}))
-    except websockets.exceptions.ConnectionClosedError:
-        print(f"Client disconnected abruptly: {websocket.remote_address}")
-    except websockets.exceptions.ConnectionClosedOK:
-        print(f"Client disconnected gracefully: {websocket.remote_address}")
-    finally:
-        connected_clients.discard(websocket)
-
-async def broadcast_message(message):
-    if connected_clients:
-        for client in connected_clients:
-            await client.send(json.dumps(message))
-
 # async def main():
 #     async with websockets.serve(websocket_handler, "localhost", 8765): # Choose a port for WebSocket
 #         print("WebSocket server started on ws://localhost:8765/ws (adjust as needed)")
@@ -360,7 +329,7 @@ def are_lines_selected():
 
 def reset_checked_lines():
     async def send_reset_message():
-        await broadcast_message({
+        await websocket_server_thread.send_text({
             'event': 'reset_checkboxes',
         })
     event_manager.reset_checked_lines()
@@ -383,23 +352,69 @@ def start_web_server():
 
 import signal
 
-async def run_websocket_server(host="0.0.0.0"):
-    global websocket_port
-    websocket = None
-    try:
-        websocket_port = get_config().advanced.texthooker_communication_websocket_port
-        websocket = await websockets.serve(websocket_handler, host, websocket_port)
-        logger.debug(f"WebSocket server started at ws://{host}:{websocket_port}/")
-        await asyncio.Future()  # Keep the server running
-    except asyncio.CancelledError:
-        logger.info("WebSocket server shutting down...")
-    except OSError as e:
-        logger.error(f"TextHooker WebSocket server failed to start on port {websocket_port}: {e}")
-        logger.info("You may need to try a different port in GSM's advanced config, and then update that in the Texthooker's settings.")
-    finally:
-        if websocket:
-            websocket.close()
-        await asyncio.sleep(1)  # Wait before retrying
+websocket_server_thread = None
+websocket_queue = queue.Queue()
+paused = False
+
+
+class WebsocketServerThread(threading.Thread):
+    def __init__(self, read):
+        super().__init__(daemon=True)
+        self._loop = None
+        self.read = read
+        self.clients = set()
+        self._event = threading.Event()
+
+    @property
+    def loop(self):
+        self._event.wait()
+        return self._loop
+
+    async def send_text_coroutine(self, message):
+        for client in self.clients:
+            await client.send(message)
+
+    async def server_handler(self, websocket):
+        self.clients.add(websocket)
+        try:
+            async for message in websocket:
+                if self.read and not paused:
+                    websocket_queue.put(message)
+                    try:
+                        await websocket.send('True')
+                    except websockets.exceptions.ConnectionClosedOK:
+                        pass
+                else:
+                    try:
+                        await websocket.send('False')
+                    except websockets.exceptions.ConnectionClosedOK:
+                        pass
+        except websockets.exceptions.ConnectionClosedError:
+            pass
+        finally:
+            self.clients.remove(websocket)
+
+    async def send_text(self, text):
+        if text:
+            return asyncio.run_coroutine_threadsafe(
+                self.send_text_coroutine(json.dumps(text)), self.loop)
+
+    def stop_server(self):
+        self.loop.call_soon_threadsafe(self._stop_event.set)
+
+    def run(self):
+        async def main():
+            self._loop = asyncio.get_running_loop()
+            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.texthooker_communication_websocket_port,
+                                                          max_size=1000000000)
+            async with start_server:
+                await stop_event.wait()
+
+        asyncio.run(main())
 
 def handle_exit_signal(loop):
     logger.info("Received exit signal. Shutting down...")
@@ -407,13 +422,16 @@ def handle_exit_signal(loop):
         task.cancel()
 
 async def texthooker_page_coro():
+    global websocket_server_thread
     # Run the WebSocket server in the asyncio event loop
     flask_thread = threading.Thread(target=start_web_server)
     flask_thread.daemon = True
     flask_thread.start()
 
+    websocket_server_thread = WebsocketServerThread(read=True)
+    websocket_server_thread.start()
+
     # Keep the main asyncio event loop running (for the WebSocket server)
-    await run_websocket_server()
 
 def run_text_hooker_page():
     try:

{gamesentenceminer-2.9.2.dist-info → gamesentenceminer-2.9.4.dist-info}/METADATA

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

{gamesentenceminer-2.9.2.dist-info → gamesentenceminer-2.9.4.dist-info}/RECORD

@@ -1,21 +1,28 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/anki.py,sha256=JnVfFkLpEfWaPfOLngU0PSQq4vrgWuhd_VLYZEBqNTY,14608
+GameSentenceMiner/anki.py,sha256=HAYblBjkth5p0tx9Z0LNQn6zuQC8_54RIB2BMzN8-LE,14705
 GameSentenceMiner/config_gui.py,sha256=h4zz85gfhxSphaJ-IZSu9D4jR70mDlKecZ9JRCO5Noc,80927
-GameSentenceMiner/configuration.py,sha256=8CfdTJ0ROJrxyzNg3NaElAVS1bwchg1ih6XfhfDZy1g,25492
+GameSentenceMiner/configuration.py,sha256=KKW6fmpxya4dmXx9cERFVrzsKCTw0vmZrF2HAJDURBU,25667
 GameSentenceMiner/electron_config.py,sha256=dGcPYCISPehXubYSzsDuI2Gl092MYK0u3bTnkL9Jh1Y,9787
-GameSentenceMiner/ffmpeg.py,sha256=zVmLJOsXpy71zKb0cLBPrXJ6YpjPVRJmH0uRfd5O30k,18299
+GameSentenceMiner/ffmpeg.py,sha256=APa2vNdAgxYdG96_Z3Xdh1WqOiWaK6gTLJqzEvCMMeU,18323
 GameSentenceMiner/gametext.py,sha256=sll-6Pficd4ZXYy8yL8hBrEOSpfa53TOye7vtHHKFN4,6218
-GameSentenceMiner/gsm.py,sha256=_Mp_gZFomeFz9FTZqYEXIgqxbICYcAB06KUlFkClX5Q,29831
+GameSentenceMiner/gsm.py,sha256=olG3BIWjbVHWTsRKmeDVE5X8XrgppWke73Fy1J15dxA,29868
 GameSentenceMiner/model.py,sha256=1lRyJFf_LND_4O16h8CWVqDfosLgr0ZS6ufBZ3qJHpY,5699
-GameSentenceMiner/notification.py,sha256=pXKoLfmRQLH55IQ5G6uxdMuczqX7D6l3ubVEY1e6hXg,2859
-GameSentenceMiner/obs.py,sha256=DoUJk00Gk0Idley7CEldfIobqJ9na2UBlCv7nclZO4s,14793
-GameSentenceMiner/obs_back.py,sha256=_N_UV7Nh5cyy3mnH5lOUOzhgZwHMACeFEuBo1Z-bNzg,10894
-GameSentenceMiner/package.py,sha256=YlS6QRMuVlm6mdXx0rlXv9_3erTGS21jaP3PNNWfAH0,1250
+GameSentenceMiner/notification.py,sha256=e6TOzZJD7RTvMgxaY-V01r5OiocHhdqEIVdAnj4MGSw,3437
+GameSentenceMiner/obs.py,sha256=JiydRMpfSpNZ0nDAzH8OOECbYbsxMNSGz46lO8lZbvA,14871
+GameSentenceMiner/package.py,sha256=uu3Yb3pqu8vN5ISzP87YCHlFNR9wxMMf5hPRncTr7ws,1181
 GameSentenceMiner/ss_selector.py,sha256=csey9H3561-guRJcT6gQN6hXxvylP0CBI0dp2-kwo2Q,4446
 GameSentenceMiner/text_log.py,sha256=U2_g8THAYeexRiE2bLk_bCt_2ShiA8SQ9VdJsi4riHs,5181
-GameSentenceMiner/util.py,sha256=PrDNnxWiJZh1lGuwnp3DjWIlwbkVxweRTYWLtQk94Ao,9122
+GameSentenceMiner/util.py,sha256=ZbK7i1UeOzKyc5WtCcttiGljR_stfu7qpnEpgqFBwro,8976
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/ai_prompting.py,sha256=xw8et6XNwQiDXOXZnw8iIntVSg8lni4YYZbgWsK7qDE,10013
+GameSentenceMiner/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/assets/icon.png,sha256=9GRL8uXUAgkUSlvbm9Pv9o2poFVRGdW6s2ub_DeUD9M,937624
+GameSentenceMiner/assets/icon128.png,sha256=l90j7biwdz5ahwOd5wZ-406ryEV9Pan93dquJQ3e1CI,18395
+GameSentenceMiner/assets/icon256.png,sha256=JEW46wOrG1KR-907rvFaEdNbPtj5gu0HJmG7qUnIHxQ,51874
+GameSentenceMiner/assets/icon32.png,sha256=Kww0hU_qke9_22wBuO_Nq0Dv2SfnOLwMhCyGgbgXdg8,6089
+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/communication/__init__.py,sha256=_jGn9PJxtOAOPtJ2rI-Qu9hEHVZVpIvWlxKvqk91_zI,638
 GameSentenceMiner/communication/send.py,sha256=X0MytGv5hY-uUvkfvdCqQA_ljZFmV6UkJ6in1TA1bUE,217
 GameSentenceMiner/communication/websocket.py,sha256=8eFZaTtoFggEPdqw2Jl4zqHC2I7J3-Gk27CxVX7SyBo,3277
@@ -43,7 +50,7 @@ GameSentenceMiner/vad/vad_utils.py,sha256=_YC6rW2eXSBeLnYbVl_F3na1KCRL90VrnOzKYJ
 GameSentenceMiner/vad/vosk_helper.py,sha256=h7yNHrzrzT-J74UniA0T2ZX8cHqhflCzwyDjoIdKLO4,6479
 GameSentenceMiner/vad/whisper_helper.py,sha256=B64-Eq_ZMCIyQX_A8uvYz-c48hSXJAyz6tSXNRaLjtA,4020
 GameSentenceMiner/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/web/texthooking_page.py,sha256=alXNkpm2Kl-ewYIm_aw24_8RdcYedLB59y6YTkp_mrE,14789
+GameSentenceMiner/web/texthooking_page.py,sha256=7Z7TGDcnj-94Y9ws7bQph4oIXrqf8Q9qVKowKimHWxM,14749
 GameSentenceMiner/web/static/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/web/static/apple-touch-icon.png,sha256=OcMI8af_68DA_tweOsQ5LytTyMwm7-hPW07IfrOVgEs,46132
 GameSentenceMiner/web/static/favicon-96x96.png,sha256=lOePzjiKl1JY2J1kT_PMdyEnrlJmi5GWbmXJunM12B4,16502
@@ -57,9 +64,9 @@ GameSentenceMiner/web/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 GameSentenceMiner/web/templates/index.html,sha256=HZKiIjiGJV8PGQ9T2aLDUNSfJn71qOwbYCjbRuSIjpY,213583
 GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
 GameSentenceMiner/web/templates/utility.html,sha256=3flZinKNqUJ7pvrZk6xu__v67z44rXnaK7UTZ303R-8,16946
-gamesentenceminer-2.9.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.9.2.dist-info/METADATA,sha256=XVxZdTUhTDvmNprnr75Eqs1Cd-6QjFDQOjjn-CeLI0Y,7280
-gamesentenceminer-2.9.2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-gamesentenceminer-2.9.2.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.9.2.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.9.2.dist-info/RECORD,,
+gamesentenceminer-2.9.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.9.4.dist-info/METADATA,sha256=jNhOj4IaiTEJqGlm4-VCtviW5hmN8J5XnvPBGWgcY0Y,7280
+gamesentenceminer-2.9.4.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+gamesentenceminer-2.9.4.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.9.4.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.9.4.dist-info/RECORD,,

GameSentenceMiner/obs_back.py

@@ -1,309 +0,0 @@
-import os.path
-import subprocess
-import threading
-import time
-import psutil
-
-from obswebsocket import obsws, requests, events
-from obswebsocket.exceptions import ConnectionFailure
-
-from GameSentenceMiner import util, configuration
-from GameSentenceMiner.configuration import *
-from GameSentenceMiner.model import *
-
-client: obsws = None
-obs_process_pid = None
-# logging.getLogger('obswebsocket').setLevel(logging.CRITICAL)
-OBS_PID_FILE = os.path.join(configuration.get_app_directory(), 'obs-studio', 'obs_pid.txt')
-
-# REFERENCE: https://github.com/obsproject/obs-websocket/blob/master/docs/generated/protocol.md
-
-
-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()
-    except (psutil.NoSuchProcess, psutil.AccessDenied, OSError):
-        if os.path.exists(OBS_PID_FILE):
-            os.remove(OBS_PID_FILE)
-        return False
-
-def start_obs():
-    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}")
-                    connect_to_obs()
-                    return obs_process_pid
-            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.")
-
-    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:
-        obs_process = subprocess.Popen([obs_path, '--disable-shutdown-check', '--portable', '--startreplaybuffer', ], cwd=os.path.dirname(obs_path))
-        obs_process_pid = obs_process.pid
-        connect_to_obs()
-        with open(OBS_PID_FILE, "w") as f:
-            f.write(str(obs_process_pid))
-        print(f"OBS launched with PID: {obs_process_pid}")
-        return obs_process_pid
-    except Exception as e:
-        print(f"Error launching OBS: {e}")
-        return None
-
-def check_obs_folder_is_correct():
-    obs_record_directory = get_record_directory()
-    if obs_record_directory and os.path.normpath(obs_record_directory) != os.path.normpath(
-            get_config().paths.folder_to_watch):
-        logger.info("OBS Path Setting wrong, OBS Recording folder in GSM Config")
-        get_config().paths.folder_to_watch = os.path.normpath(obs_record_directory)
-        get_master_config().sync_shared_fields()
-        save_full_config(get_master_config())
-
-
-def get_obs_websocket_config_values():
-    config_path = os.path.join(get_app_directory(), 'obs-studio', 'config', 'obs-studio', 'plugin_config', 'obs-websocket', 'config.json')
-
-        # Check if config file exists
-    if not os.path.isfile(config_path):
-        raise FileNotFoundError(f"OBS WebSocket config not found at {config_path}")
-
-    # Read the JSON configuration
-    with open(config_path, 'r') as file:
-        config = json.load(file)
-
-    # Extract values
-    server_enabled = config.get("server_enabled", False)
-    server_port = config.get("server_port", 7274)  # Default to 4455 if not set
-    server_password = config.get("server_password", None)
-
-    if not server_enabled:
-        logger.info("OBS WebSocket server is not enabled. Enabling it now... Restart OBS for changes to take effect.")
-        config["server_enabled"] = True
-
-        with open(config_path, 'w') as file:
-            json.dump(config, file, indent=4)
-
-    if get_config().obs.password == 'your_password':
-        logger.info("OBS WebSocket password is not set. Setting it now...")
-        full_config = get_master_config()
-        full_config.get_config().obs.port = server_port
-        full_config.get_config().obs.password = server_password
-        full_config.sync_shared_fields()
-        full_config.save()
-        reload_config()
-
-
-connected = False
-
-def on_connect(obs):
-    global connected
-    logger.info("Reconnected to OBS WebSocket.")
-    start_replay_buffer()
-    connected = True
-
-
-def on_disconnect(obs):
-    global connected
-    logger.error("OBS Connection Lost!")
-    connected = False
-
-
-def connect_to_obs(retry_count=0):
-    global client
-    if not get_config().obs.enabled or client:
-        return
-
-    if util.is_windows():
-        get_obs_websocket_config_values()
-
-    try:
-        client = obsws(
-            host=get_config().obs.host,
-            port=get_config().obs.port,
-            password=get_config().obs.password,
-            authreconnect=1,
-            on_connect=on_connect,
-            on_disconnect=on_disconnect
-        )
-        client.connect()
-        update_current_game()
-    except ConnectionFailure as e:
-        if retry_count % 5 == 0:
-            logger.error(f"Failed to connect to OBS WebSocket: {e}. Retrying...")
-        time.sleep(1)
-        connect_to_obs(retry_count=retry_count + 1)
-
-
-# Disconnect from OBS WebSocket
-def disconnect_from_obs():
-    global client
-    if client:
-        client.disconnect()
-        client = None
-        logger.info("Disconnected from OBS WebSocket.")
-
-def do_obs_call(request, from_dict=None, retry=3):
-    connect_to_obs()
-    for _ in range(retry + 1):
-        try:
-            response = client.call(request)
-            if response and response.status:
-                return from_dict(response.datain) if from_dict else response.datain
-            time.sleep(0.3)
-        except Exception as e:
-            logger.error(f"Error calling OBS: {e}")
-            if "socket is already closed" in str(e) or "object has no attribute" in str(e):
-                time.sleep(0.3)
-            else:
-                return None
-    return None
-
-def toggle_replay_buffer():
-    try:
-        do_obs_call(requests.ToggleReplayBuffer())
-        logger.info("Replay buffer Toggled.")
-    except Exception as e:
-        logger.error(f"Error toggling buffer: {e}")
-
-
-# Start replay buffer
-def start_replay_buffer(retry=5):
-    try:
-        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:
-                time.sleep(1)
-                start_replay_buffer(retry - 1)
-            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():
-    try:
-        client.call(requests.StopReplayBuffer())
-        logger.error("Replay buffer stopped.")
-    except Exception as e:
-        logger.error(f"Error stopping replay buffer: {e}")
-
-# Save the current replay buffer
-def save_replay_buffer():
-    replay_buffer_started = do_obs_call(requests.GetReplayBufferStatus())['outputActive']
-    if replay_buffer_started:
-        client.call(requests.SaveReplayBuffer())
-        logger.info("Replay buffer saved. If your log stops bere, make sure your obs output path matches \"Path To Watch\" in GSM settings.")
-    else:
-        logger.error("Replay Buffer is not active, could not save Replay Buffer!")
-
-
-def get_current_scene():
-    try:
-        return do_obs_call(requests.GetCurrentProgramScene(), SceneInfo.from_dict, retry=0).sceneName
-    except Exception as e:
-        logger.debug(f"Couldn't get scene: {e}")
-    return ''
-
-
-def get_source_from_scene(scene_name):
-    try:
-        return do_obs_call(requests.GetSceneItemList(sceneName=scene_name), SceneItemsResponse.from_dict).sceneItems[0]
-    except Exception as e:
-        logger.error(f"Error getting source from scene: {e}")
-        return ''
-
-def get_record_directory():
-    try:
-        return do_obs_call(requests.GetRecordDirectory(), RecordDirectory.from_dict).recordDirectory
-    except Exception as e:
-        logger.error(f"Error getting recording folder: {e}")
-        return ''
-
-def get_obs_scenes():
-    try:
-        response: SceneListResponse = do_obs_call(requests.GetSceneList(), SceneListResponse.from_dict, retry=0)
-        return response.scenes
-    except Exception as e:
-        logger.error(f"Error getting scenes: {e}")
-        return None
-
-def register_scene_change_callback(callback):
-    global client
-    if not client:
-        logger.error("OBS client is not connected.")
-        return
-
-    def on_scene_change(data):
-        logger.info("Scene changed: " + str(data))
-        scene_name = data.getSceneName()
-        if scene_name:
-            callback(scene_name)
-
-    client.register(on_scene_change, events.CurrentProgramSceneChanged)
-    logger.info("Scene change callback registered.")
-
-
-def get_screenshot(compression=-1):
-    try:
-        screenshot = util.make_unique_file_name(os.path.abspath(
-            configuration.get_temporary_directory()) + '/screenshot.png')
-        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
-        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()
-
-
-def get_current_game(sanitize=False):
-    if not configuration.current_game:
-        update_current_game()
-
-    if sanitize:
-        return util.sanitize_filename(configuration.current_game)
-    return configuration.current_game