GameSentenceMiner 2.15.3__py3-none-any.whl → 2.15.5__py3-none-any.whl

GameSentenceMiner/obs.py

@@ -5,6 +5,7 @@ import subprocess
 import threading
 import time
 import logging
+import contextlib
 
 import psutil
 
@@ -16,7 +17,7 @@ from GameSentenceMiner.util.gsm_utils import sanitize_filename, make_unique_file
 import tkinter as tk
 from tkinter import messagebox
 
-client: obs.ReqClient = None
+connection_pool: 'OBSConnectionPool' = None
 event_client: obs.EventClient = None
 obs_process_pid = None
 OBS_PID_FILE = os.path.join(configuration.get_app_directory(), 'obs-studio', 'obs_pid.txt')
@@ -24,8 +25,83 @@ obs_connection_manager = None
 logging.getLogger("obsws_python").setLevel(logging.CRITICAL)
 connecting = False
 
+class OBSConnectionPool:
+    """Manages a pool of thread-safe connections to the OBS WebSocket."""
+    def __init__(self, size=3, **kwargs):
+        self.size = size
+        self.connection_kwargs = kwargs
+        self._clients = [None] * self.size
+        self._locks = [threading.Lock() for _ in range(self.size)]
+        self._next_idx = 0
+        self._idx_lock = threading.Lock()
+        logger.info(f"Initialized OBSConnectionPool with size {self.size}")
+
+    def connect_all(self):
+        """Initializes all client objects in the pool."""
+        for i in range(self.size):
+            try:
+                self._clients[i] = obs.ReqClient(**self.connection_kwargs)
+            except Exception as e:
+                logger.error(f"Failed to create client {i} in pool: {e}")
+        return True
+
+    def disconnect_all(self):
+        """Disconnects all clients in the pool."""
+        for client in self._clients:
+            if client:
+                try:
+                    client.disconnect()
+                except Exception:
+                    pass
+        self._clients = [None] * self.size
+        logger.info("Disconnected all clients in OBSConnectionPool.")
+
+    def _check_and_reconnect(self, index):
+        """Checks a specific client and reconnects if necessary."""
+        client = self._clients[index]
+        if not client:
+            self._clients[index] = obs.ReqClient(**self.connection_kwargs)
+            logger.info(f"Re-initialized client {index} in pool.")
+            return
+        try:
+            client.get_version()
+        except Exception:
+            logger.info(f"Reconnecting client {index} in pool.")
+            try:
+                client.disconnect()
+            except Exception:
+                pass
+            self._clients[index] = obs.ReqClient(**self.connection_kwargs)
+
+    @contextlib.contextmanager
+    def get_client(self):
+        """A context manager to safely get a client from the pool."""
+        with self._idx_lock:
+            idx = self._next_idx
+            self._next_idx = (self._next_idx + 1) % self.size
+
+        lock = self._locks[idx]
+        lock.acquire()
+        try:
+            self._check_and_reconnect(idx)
+            yield self._clients[idx]
+        finally:
+            lock.release()
+
+    def get_healthcheck_client(self):
+        """Returns a dedicated client for health checks, separate from the main pool."""
+        if not hasattr(self, '_healthcheck_client') or self._healthcheck_client is None:
+            try:
+                self._healthcheck_client = obs.ReqClient(**self.connection_kwargs)
+                logger.info("Initialized dedicated healthcheck client.")
+            except Exception as e:
+                logger.error(f"Failed to create healthcheck client: {e}")
+                self._healthcheck_client = None
+        return self._healthcheck_client
+
+
 class OBSConnectionManager(threading.Thread):
-    def __init__(self, check_output=True):
+    def __init__(self, check_output=False):
         super().__init__()
         self.daemon = True
         self.running = True
@@ -38,8 +114,11 @@ class OBSConnectionManager(threading.Thread):
         while self.running:
             time.sleep(self.check_connection_interval)
             try:
-                if not connecting:
+                client = connection_pool.get_healthcheck_client() if connection_pool else None
+                if client and not connecting:
                     client.get_version()
+                else:
+                    raise ConnectionError("Healthcheck client not healthy or not initialized")
             except Exception as e:
                 logger.info(f"OBS WebSocket not connected. Attempting to reconnect... {e}")
                 gsm_status.obs_connected = False
@@ -128,12 +207,12 @@ def start_obs():
         return None
 
 async def wait_for_obs_connected():
-    global client
-    if not client:
+    if not connection_pool:
         return False
     for _ in range(10):
         try:
-            response = client.get_version()
+            with connection_pool.get_client() as client:
+                response = client.get_version()
             if response:
                 return True
         except Exception as e:
@@ -182,20 +261,26 @@ def get_obs_websocket_config_values():
         full_config.save()
         reload_config()
 
-async def connect_to_obs(retry=5, check_output=True):
-    global client, obs_connection_manager, event_client, connecting
+async def connect_to_obs(retry=5, connections=2, check_output=False):
+    global connection_pool, obs_connection_manager, event_client, connecting
     if is_windows():
         get_obs_websocket_config_values()
 
     while True:
         connecting = True
         try:
-            client = obs.ReqClient(
-                host=get_config().obs.host,
-                port=get_config().obs.port,
-                password=get_config().obs.password,
-                timeout=1,
-            )
+            pool_kwargs = {
+                'host': get_config().obs.host,
+                'port': get_config().obs.port,
+                'password': get_config().obs.password,
+                'timeout': 3,
+            }
+            connection_pool = OBSConnectionPool(size=connections, **pool_kwargs)
+            connection_pool.connect_all()
+
+            with connection_pool.get_client() as client:
+                client.get_version() # Test one connection to confirm it works
+
             event_client = obs.EventClient(
                 host=get_config().obs.host,
                 port=get_config().obs.port,
@@ -213,7 +298,7 @@ async def connect_to_obs(retry=5, check_output=True):
             if retry <= 0:
                 gsm_status.obs_connected = False
                 logger.error(f"Failed to connect to OBS WebSocket: {e}")
-                client = None
+                connection_pool = None
                 event_client = None
                 connecting = False
                 break
@@ -221,70 +306,49 @@ async def connect_to_obs(retry=5, check_output=True):
             retry -= 1
     connecting = False
 
-def connect_to_obs_sync(retry=2, check_output=True):
-    global client, obs_connection_manager, event_client
-    if is_windows():
-        get_obs_websocket_config_values()
-
-    while True:
-        try:
-            client = obs.ReqClient(
-                host=get_config().obs.host,
-                port=get_config().obs.port,
-                password=get_config().obs.password,
-                timeout=1,
-            )
-            event_client = obs.EventClient(
-                host=get_config().obs.host,
-                port=get_config().obs.port,
-                password=get_config().obs.password,
-                timeout=1,
-            )
-            if not obs_connection_manager:
-                obs_connection_manager = OBSConnectionManager(check_output=check_output)
-                obs_connection_manager.start()
-            update_current_game()
-            logger.info("Connected to OBS WebSocket.")
-            break  # Exit the loop once connected
-        except Exception as e:
-            if retry <= 0:
-                gsm_status.obs_connected = False
-                logger.error(f"Failed to connect to OBS WebSocket: {e}")
-                client = None
-                event_client = None
-                break
-            time.sleep(1)
-            retry -= 1
+def connect_to_obs_sync(retry=2, connections=2, check_output=False):
+    asyncio.run(connect_to_obs(retry=retry, connections=connections, check_output=check_output))
 
 
 def disconnect_from_obs():
-    global client
-    if client:
-        client.disconnect()
-        client = None
+    global connection_pool
+    if connection_pool:
+        connection_pool.disconnect_all()
+        connection_pool = None
         logger.info("Disconnected from OBS WebSocket.")
 
-def do_obs_call(request, *args, from_dict=None, retry=3):
-    connect_to_obs()
-    if not client:
+def do_obs_call(method_name: str, from_dict=None, retry=3, **kwargs):
+    if not connection_pool:
+        connect_to_obs_sync(retry=1)
+    if not connection_pool:
         return None
+
+    last_exception = None
     for _ in range(retry + 1):
         try:
-            response = request(*args)
-            if response and response.ok:
-                return from_dict(response.datain) if from_dict else response.datain
+            with connection_pool.get_client() as client:
+                method_to_call = getattr(client, method_name)
+                response = method_to_call(**kwargs)
+                if response and response.ok:
+                    return from_dict(response.datain) if from_dict else response.datain
             time.sleep(0.3)
+        except AttributeError:
+             logger.error(f"OBS client has no method '{method_name}'")
+             return None
         except Exception as e:
-            logger.error(f"Error calling OBS: {e}")
+            last_exception = e
+            logger.error(f"Error calling OBS ('{method_name}'): {e}")
             if "socket is already closed" in str(e) or "object has no attribute" in str(e):
                 time.sleep(0.3)
             else:
                 return None
+    logger.error(f"OBS call '{method_name}' failed after retries. Last error: {last_exception}")
     return None
 
 def toggle_replay_buffer():
     try:
-        response = client.toggle_replay_buffer()
+        with connection_pool.get_client() as client:
+            response = client.toggle_replay_buffer()
         if response:
             logger.info("Replay buffer Toggled.")
     except Exception as e:
@@ -292,7 +356,8 @@ def toggle_replay_buffer():
 
 def start_replay_buffer():
     try:
-        response = client.start_replay_buffer()
+        with connection_pool.get_client() as client:
+            response = client.start_replay_buffer()
         if response and response.ok:
             logger.info("Replay buffer started.")
     except Exception as e:
@@ -300,31 +365,34 @@ def start_replay_buffer():
 
 def get_replay_buffer_status():
     try:
-        return client.get_replay_buffer_status().output_active
+        with connection_pool.get_client() as client:
+            return client.get_replay_buffer_status().output_active
     except Exception as e:
         logger.debug(f"Error getting replay buffer status: {e}")
         return None
 
 def stop_replay_buffer():
     try:
-        response = client.stop_replay_buffer()
+        with connection_pool.get_client() as client:
+            response = client.stop_replay_buffer()
         if response and response.ok:
             logger.info("Replay buffer stopped.")
     except Exception as e:
         logger.warning(f"Error stopping replay buffer: {e}")
 
 def save_replay_buffer():
-    status = get_replay_buffer_status()
-    if status:
-        response = client.save_replay_buffer()
+    try:
+        with connection_pool.get_client() as client:
+            response = client.save_replay_buffer()
         if response and response.ok:
             logger.info("Replay buffer saved. If your log stops here, make sure your obs output path matches \"Path To Watch\" in GSM settings.")
-    else:
-        raise Exception("Replay Buffer is not active, could not save Replay Buffer!")
+    except Exception as e:
+        raise Exception(f"Error saving replay buffer: {e}")
 
 def get_current_scene():
     try:
-        response = client.get_current_program_scene()
+        with connection_pool.get_client() as client:
+            response = client.get_current_program_scene()
         return response.scene_name if response else ''
     except Exception as e:
         logger.debug(f"Couldn't get scene: {e}")
@@ -332,7 +400,8 @@ def get_current_scene():
 
 def get_source_from_scene(scene_name):
     try:
-        response = client.get_scene_item_list(name=scene_name)
+        with connection_pool.get_client() as client:
+            response = client.get_scene_item_list(name=scene_name)
         return response.scene_items[0] if response and response.scene_items else ''
     except Exception as e:
         logger.error(f"Error getting source from scene: {e}")
@@ -346,7 +415,8 @@ def get_active_source():
 
 def get_record_directory():
     try:
-        response = client.get_record_directory()
+        with connection_pool.get_client() as client:
+            response = client.get_record_directory()
         return response.record_directory if response else ''
     except Exception as e:
         logger.error(f"Error getting recording folder: {e}")
@@ -354,17 +424,17 @@ def get_record_directory():
 
 def get_obs_scenes():
     try:
-        response = client.get_scene_list()
+        with connection_pool.get_client() as client:
+            response = client.get_scene_list()
         return response.scenes if response else None
     except Exception as e:
         logger.error(f"Error getting scenes: {e}")
         return None
 
 async def register_scene_change_callback(callback):
-    global client
     if await wait_for_obs_connected():
-        if not client:
-            logger.error("OBS client is not connected.")
+        if not connection_pool:
+            logger.error("OBS connection pool is not connected.")
             return
 
         def on_current_program_scene_changed(data):
@@ -391,7 +461,8 @@ def get_screenshot(compression=-1):
             return None
         start = time.time()
         logger.debug(f"Current source name: {current_source_name}")
-        client.save_source_screenshot(name=current_source_name, img_format='png', width=None, height=None, file_path=screenshot, quality=compression)
+        with connection_pool.get_client() as client:
+            client.save_source_screenshot(name=current_source_name, img_format='png', width=None, height=None, file_path=screenshot, quality=compression)
         logger.debug(f"Screenshot took {time.time() - start:.3f} seconds to save")
         return screenshot
     except Exception as e:
@@ -410,11 +481,10 @@ def get_screenshot_base64(compression=75, width=None, height=None):
         if not current_source_name:
             logger.error("No active source found in the current scene.")
             return None
-        # version = client.send("GetVersion", raw=True)
-        # pprint(version)
-        # responseraw = client.send("GetSourceScreenshot", {"sourceName": current_source_name, "imageFormat": "png", "imageWidth": width, "imageHeight": height, "compressionQuality": compression}, raw=True)
-        response = client.get_source_screenshot(name=current_source_name, img_format='png', quality=compression, width=width, height=height)
-        # print(responseraw)
+
+        with connection_pool.get_client() as client:
+            response = client.get_source_screenshot(name=current_source_name, img_format='png', quality=compression, width=width, height=height)
+
         if response and response.image_data:
             return response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
         else:
@@ -435,7 +505,8 @@ def get_screenshot_PIL(source_name=None, compression=75, img_format='png', width
         logger.error("No active source found in the current scene.")
         return None
     while True:
-        response = client.get_source_screenshot(name=source_name, img_format=img_format, quality=compression, width=width, height=height)
+        with connection_pool.get_client() as client:
+            response = client.get_source_screenshot(name=source_name, img_format=img_format, quality=compression, width=width, height=height)
         try:
             response.image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
         except AttributeError:
@@ -448,8 +519,6 @@ def get_screenshot_PIL(source_name=None, compression=75, img_format='png', width
             image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
             image_data = base64.b64decode(image_data)
             img = Image.open(io.BytesIO(image_data)).convert("RGBA")
-        # if width and height:
-            # img = img.resize((width, height), Image.Resampling.LANCZOS)
             return img
     return None
 
@@ -472,103 +541,84 @@ def get_current_game(sanitize=False, update=True):
 def set_fit_to_screen_for_scene_items(scene_name: str):
     """
     Sets all sources in a given scene to "Fit to Screen" (like Ctrl+F in OBS).
-
-    This function fetches the canvas dimensions, then iterates through all scene
-    items in the specified scene and applies a transform that scales them to
-    fit within the canvas while maintaining aspect ratio and centering them.
-
-    Args:
-        scene_name: The name of the scene to modify.
     """
+    if not scene_name:
+        return
+        
     try:
-        # 1. Get the canvas (base) resolution from OBS video settings
-        video_settings = client.get_video_settings()
-        if not hasattr(video_settings, 'base_width') or not hasattr(video_settings, 'base_height'):
-            logger.debug("Video settings do not have base_width or base_height attributes, probably weird websocket error issue? Idk what causes it..")
-            return
-        canvas_width = video_settings.base_width
-        canvas_height = video_settings.base_height
+        with connection_pool.get_client() as client:
+            # 1. Get the canvas (base) resolution from OBS video settings
+            video_settings = client.get_video_settings()
+            if not hasattr(video_settings, 'base_width') or not hasattr(video_settings, 'base_height'):
+                logger.debug("Video settings do not have base_width or base_height attributes, probably weird websocket error issue? Idk what causes it..")
+                return
+            canvas_width = video_settings.base_width
+            canvas_height = video_settings.base_height
 
-        # 2. Get the list of items in the specified scene
-        scene_items_response = client.get_scene_item_list(scene_name)
-        items = scene_items_response.scene_items if scene_items_response.scene_items else []
+            # 2. Get the list of items in the specified scene
+            scene_items_response = client.get_scene_item_list(scene_name)
+            items = scene_items_response.scene_items if scene_items_response.scene_items else []
 
-        if not items:
-            logger.warning(f"No items found in scene '{scene_name}'.")
-            return
+            if not items:
+                logger.warning(f"No items found in scene '{scene_name}'.")
+                return
 
-        # 3. Loop through each item and apply the "Fit to Screen" transform
-        for item in items:
-            item_id = item['sceneItemId']
-            source_name = item['sourceName']
-            
-            scene_item_transform = item.get('sceneItemTransform', {})
-            
-            source_width = scene_item_transform.get('sourceWidth', None)
-            source_height = scene_item_transform.get('sourceHeight', None)
-
-            aspect_ratio_different = False
-            already_cropped = any([
-                scene_item_transform.get('cropLeft', 0) != 0,
-                scene_item_transform.get('cropRight', 0) != 0,
-                scene_item_transform.get('cropTop', 0) != 0,
-                scene_item_transform.get('cropBottom', 0) != 0,
-            ])
-            
-            if source_width and source_height and not already_cropped:
-                source_aspect_ratio = source_width / source_height
-                canvas_aspect_ratio = canvas_width / canvas_height
-                # Check if aspect ratio is different and if it's a standard aspect ratio
-                aspect_ratio_different = abs(source_aspect_ratio - canvas_aspect_ratio) > 0.01
-
-                # List of standard aspect ratios
-                standard_ratios = [
-                    4 / 3,
-                    16 / 9,
-                    16 / 10,
-                    21 / 9,
-                    32 / 9,
-                    5 / 4,
-                    3 / 2,
-                ]
-
-                def is_standard_ratio(ratio):
-                    return any(abs(ratio - std) < 0.02 for std in standard_ratios)
-
-                # Only crop if both source and canvas are standard aspect ratios
-                if aspect_ratio_different:
-                    if not (is_standard_ratio(source_aspect_ratio) and is_standard_ratio(canvas_aspect_ratio)):
-                        aspect_ratio_different = False
-            
-            # This transform object is the equivalent of "Fit to Screen"
-            fit_to_screen_transform = {
-                'boundsType': 'OBS_BOUNDS_SCALE_INNER',
-                'alignment': 5,  # 5 = Center alignment (horizontal and vertical)
-                'boundsWidth': canvas_width,
-                'boundsHeight': canvas_height,
-                'positionX': 0,
-                'positionY': 0,
-            }
-            
-            if not already_cropped:
-                fit_to_screen_transform.update({
-                    'cropLeft': 0 if not aspect_ratio_different or canvas_width > source_width else (source_width - canvas_width) // 2,
-                    'cropRight': 0 if not aspect_ratio_different or canvas_width > source_width else (source_width - canvas_width) // 2,
-                    'cropTop': 0 if not aspect_ratio_different or canvas_height > source_height else (source_height - canvas_height) // 2,
-                    'cropBottom': 0 if not aspect_ratio_different or canvas_height > source_height else (source_height - canvas_height) // 2,
-                })
+            # 3. Loop through each item and apply the "Fit to Screen" transform
+            for item in items:
+                item_id = item['sceneItemId']
+                source_name = item['sourceName']
+                
+                scene_item_transform = item.get('sceneItemTransform', {})
+                
+                source_width = scene_item_transform.get('sourceWidth', None)
+                source_height = scene_item_transform.get('sourceHeight', None)
+
+                aspect_ratio_different = False
+                already_cropped = any([
+                    scene_item_transform.get('cropLeft', 0) != 0,
+                    scene_item_transform.get('cropRight', 0) != 0,
+                    scene_item_transform.get('cropTop', 0) != 0,
+                    scene_item_transform.get('cropBottom', 0) != 0,
+                ])
+                
+                if source_width and source_height and not already_cropped:
+                    source_aspect_ratio = source_width / source_height
+                    canvas_aspect_ratio = canvas_width / canvas_height
+                    aspect_ratio_different = abs(source_aspect_ratio - canvas_aspect_ratio) > 0.01
+
+                    standard_ratios = [4 / 3, 16 / 9, 16 / 10, 21 / 9, 32 / 9, 5 / 4, 3 / 2]
+
+                    def is_standard_ratio(ratio):
+                        return any(abs(ratio - std) < 0.02 for std in standard_ratios)
+
+                    if aspect_ratio_different:
+                        if not (is_standard_ratio(source_aspect_ratio) and is_standard_ratio(canvas_aspect_ratio)):
+                            aspect_ratio_different = False
+                
+                fit_to_screen_transform = {
+                    'boundsType': 'OBS_BOUNDS_SCALE_INNER', 'alignment': 5,
+                    'boundsWidth': canvas_width, 'boundsHeight': canvas_height,
+                    'positionX': 0, 'positionY': 0,
+                }
+                
+                if not already_cropped:
+                    fit_to_screen_transform.update({
+                        'cropLeft': 0 if not aspect_ratio_different or canvas_width > source_width else (source_width - canvas_width) // 2,
+                        'cropRight': 0 if not aspect_ratio_different or canvas_width > source_width else (source_width - canvas_width) // 2,
+                        'cropTop': 0 if not aspect_ratio_different or canvas_height > source_height else (source_height - canvas_height) // 2,
+                        'cropBottom': 0 if not aspect_ratio_different or canvas_height > source_height else (source_height - canvas_height) // 2,
+                    })
 
-            try:
-                client.set_scene_item_transform(
-                    scene_name=scene_name,
-                    item_id=item_id,
-                    transform=fit_to_screen_transform
-                )
-            except obs.error.OBSSDKError as e:
-                logger.error(f"Failed to set transform for source '{source_name}': {e}")
+                try:
+                    client.set_scene_item_transform(
+                        scene_name=scene_name,
+                        item_id=item_id,
+                        transform=fit_to_screen_transform
+                    )
+                except obs.error.OBSSDKError as e:
+                    logger.error(f"Failed to set transform for source '{source_name}': {e}")
 
     except obs.error.OBSSDKError as e:
-        # This will catch errors like "scene not found"
         logger.error(f"An OBS error occurred: {e}")
     except Exception as e:
         logger.error(f"An unexpected error occurred: {e}")
@@ -576,12 +626,14 @@ def set_fit_to_screen_for_scene_items(scene_name: str):
 
 def main():
     start_obs()
-    connect_to_obs()
+    # connect_to_obs() is async, main is not. Use the sync version.
+    connect_to_obs_sync()
     # Test each method
     print("Testing `get_obs_path`:", get_obs_path())
     print("Testing `is_process_running` with PID 1:", is_process_running(1))
     print("Testing `check_obs_folder_is_correct`:")
-    check_obs_folder_is_correct()
+    # This is async, need to run it in an event loop if testing from main
+    asyncio.run(check_obs_folder_is_correct())
     print("Testing `get_obs_websocket_config_values`:")
     try:
         get_obs_websocket_config_values()
@@ -595,10 +647,13 @@ def main():
     print("Testing `stop_replay_buffer`:")
     stop_replay_buffer()
     print("Testing `save_replay_buffer`:")
-    save_replay_buffer()
+    try:
+        save_replay_buffer()
+    except Exception as e:
+        print(f"Could not save replay buffer: {e}")
     current_scene = get_current_scene()
     print("Testing `get_current_scene`:", current_scene)
-    print("Testing `get_source_from_scene` with dummy scene:", get_source_from_scene(current_scene))
+    print("Testing `get_source_from_scene` with current scene:", get_source_from_scene(current_scene))
     print("Testing `get_record_directory`:", get_record_directory())
     print("Testing `get_obs_scenes`:", get_obs_scenes())
     print("Testing `get_screenshot`:", get_screenshot())
@@ -612,51 +667,4 @@ def main():
 if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO)
     connect_to_obs_sync()
-    set_fit_to_screen_for_scene_items(get_current_scene())
-    # main()
-    # connect_to_obs_sync()
-    # img = get_screenshot_PIL(source_name="Display Capture 2", compression=75, img_format='png', width=1280, height=720)
-    # img.show()
-    # while True:
-    #     print(get_active_source())
-    #     time.sleep(3)
-    # i = 100
-    # for i in range(1, 100):
-    #     print(f"Getting screenshot {i}")
-    #     start = time.time()
-    # # get_screenshot(compression=95)
-    # # get_screenshot_base64(compression=95, width=1280, height=720)
-    
-    #     img = get_screenshot_PIL(compression=i, img_format='jpg', width=1280, height=720)
-    #     end = time.time()
-    #     print(f"Time taken to get screenshot with compression {i}: {end - start} seconds")
-        
-    # for i in range(1, 100):
-    #     print(f"Getting screenshot {i}")
-    #     start = time.time()
-    # # get_screenshot(compression=95)
-    # # get_screenshot_base64(compression=95, width=1280, height=720)
-    
-    #     img = get_screenshot_PIL(compression=i, img_format='jpg', width=2560, height=1440)
-    #     end = time.time()
-    #     print(f"Time taken to get screenshot full sized jpg with compression {i}: {end - start} seconds")
-
-    # png_img = get_screenshot_PIL(compression=75, img_format='png', width=1280, height=720)
-
-    # jpg_img = get_screenshot_PIL(compression=100, img_format='jpg', width=2560, height=1440)
-
-    # png_img.show()
-    # jpg_img.show()
-    
-    # start = time.time()
-    # with mss() as sct:
-    #     monitor = sct.monitors[1]
-    #     sct_img = sct.grab(monitor)
-    #     img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
-    #     img.show()
-    # end = time.time()
-    # print(f"Time taken to get screenshot with mss: {end - start} seconds")
-
-    
-    # print(get_screenshot_base64(compression=75, width=1280, height=720))
-
+    set_fit_to_screen_for_scene_items(get_current_scene())