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

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):

GameSentenceMiner/obs.py

@@ -8,6 +8,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 +141,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 +175,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/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-2.9.2.dist-info → gamesentenceminer-2.9.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.9.2
+Version: 2.9.3
 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.3.dist-info}/RECORD

@@ -1,19 +1,18 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/anki.py,sha256=JnVfFkLpEfWaPfOLngU0PSQq4vrgWuhd_VLYZEBqNTY,14608
 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/notification.py,sha256=fPTbZJG82YLsppjC0sByQ0SX3bSsvDWXzG498HBEGMY,2823
+GameSentenceMiner/obs.py,sha256=OntCO14G2KjzMk6bztqhQWiDiNzjzPpL_KHKXasxJq4,14886
 GameSentenceMiner/package.py,sha256=YlS6QRMuVlm6mdXx0rlXv9_3erTGS21jaP3PNNWfAH0,1250
 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/communication/__init__.py,sha256=_jGn9PJxtOAOPtJ2rI-Qu9hEHVZVpIvWlxKvqk91_zI,638
@@ -57,9 +56,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.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.9.3.dist-info/METADATA,sha256=XlzEKeMFA9JKtiEU_pxShJbopSnIKKdL7cRsg25JxqQ,7280
+gamesentenceminer-2.9.3.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+gamesentenceminer-2.9.3.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.9.3.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.9.3.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