feat: Refactor webcam snapshot handling and add new configuration options for notifications (#108)

Author: Clon1998

mobileraker.py

@@ -1,21 +1,24 @@
-import argparse
 import asyncio
+import argparse
 import logging
 import os
+import sys
+from asyncio import AbstractEventLoop
+
 from mobileraker.client.mobileraker_fcm_client import MobilerakerFcmClient
 from mobileraker.client.moonraker_client import MoonrakerClient
-from mobileraker.client.snapshot_client import SnapshotClient
+from mobileraker.client.webcam_snapshot_client import WebcamSnapshotClient
 from mobileraker.mobileraker_companion import MobilerakerCompanion
 from mobileraker.service.data_sync_service import DataSyncService
 from mobileraker.util.configs import CompanionLocalConfig, printer_data_logs_dir
 from mobileraker.util.functions import get_software_version
 from mobileraker.util.logging import setup_logging
 
 
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        description="Mobileraker - Companion")
-
+# Main entry point
+async def main(args):
+    # Parse arguments
+    parser = argparse.ArgumentParser(description="MobilerakerCompanion - An app for push notifications for Klipper/Moonraker")
     parser.add_argument(
         "-l", "--logfile", default=os.path.join(printer_data_logs_dir if os.path.exists(printer_data_logs_dir) else '/tmp', "mobileraker.log"), metavar='<logfile>',
         help="Log File Location or log file absolute path")
@@ -26,64 +29,117 @@ def main() -> None:
         "-c", "--configfile", default="~/Mobileraker.conf", metavar='<configfile>',
         help="Location of the configuration file for Mobileraker Companion"
     )
-
-    cmd_line_args = parser.parse_args()
+    
+    parsed_args = parser.parse_args(args)
 
     version = get_software_version()
-    if not cmd_line_args.nologfile:
-        setup_logging(os.path.normpath(os.path.expanduser(
-            cmd_line_args.logfile)), version)
 
+    # Setup logging
+    if not parsed_args.nologfile:
+        setup_logging(os.path.normpath(os.path.expanduser(
+            parsed_args.logfile)), version)
+    
     logging.info(f"MobilerakerCompanion version: {version}")
-
-    passed_config_location = os.path.normpath(
-        os.path.expanduser(cmd_line_args.configfile))
-
-    local_config = CompanionLocalConfig(passed_config_location)
-    event_loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(event_loop)
-    fcmc = MobilerakerFcmClient(
-        # 'http://127.0.0.1:8080',
-        'https://mobileraker.eliteschw31n.de',
-        event_loop)
+    
+    # Load the config
+    config = CompanionLocalConfig(parsed_args.configfile)
+    
+    # Get the event loop
+    loop = asyncio.get_event_loop()
+    
     try:
-        printers = local_config.printers
-        for printer_name in printers:
-            p_config = printers[printer_name]
-
-            jrpc = MoonrakerClient(
-                p_config['moonraker_uri'],
-                p_config['moonraker_api_key'],
-                printer_name,
-                event_loop)
-
-            snc = SnapshotClient(
-                p_config['snapshot_uri'],
-                p_config['snapshot_rotation'],
+        # Create a task for each printer
+        tasks = []
+        for printer_name, printer_cfg in config.printers.items():
+            task = loop.create_task(
+                setup_printer_companion(
+                    printer_name,
+                    printer_cfg,
+                    config,
+                    loop
+                )
             )
+            tasks.append(task)
+        
+        # Wait for all tasks to complete
+        await asyncio.gather(*tasks)
+        
+    except KeyboardInterrupt:
+        logging.info("Received keyboard interrupt, shutting down...")
+    except Exception as e:
+        logging.exception(f"Unhandled exception: {e}")
+    finally:
+        # Close the event loop
+        loop.close()
 
-            dsd = DataSyncService(
-                jrpc=jrpc,
-                printer_name=printer_name,
-                loop=event_loop,
-            )
 
-            client = MobilerakerCompanion(
-                jrpc=jrpc,
-                data_sync_service=dsd,
-                fcm_client=fcmc,
-                snapshot_client=snc,
-                printer_name=printer_name,
-                loop=event_loop,
-                companion_config=local_config,
-                exclude_sensors=p_config['excluded_filament_sensors'],
-            )
-            event_loop.create_task(client.start())
-        event_loop.run_forever()
-    finally:
-        event_loop.close()
-    exit()
+async def setup_printer_companion(
+    printer_name: str,
+    printer_cfg: dict,
+    companion_config: CompanionLocalConfig,
+    loop: AbstractEventLoop
+):
+    """
+    Set up the MobilerakerCompanion for a specific printer.
+    
+    Args:
+        printer_name (str): The name of the printer.
+        printer_cfg (dict): The printer configuration.
+        companion_config (CompanionLocalConfig): The companion configuration.
+        loop (AbstractEventLoop): The event loop.
+    """
+    moonraker_uri = printer_cfg["moonraker_uri"]
+    moonraker_api_key = printer_cfg["moonraker_api_key"]
+    snapshot_uri = printer_cfg["snapshot_uri"]
+    snapshot_rotation = printer_cfg["snapshot_rotation"]
+    exclude_sensors = printer_cfg["excluded_filament_sensors"]
+    
+    # Create the JRPC client
+    jrpc = MoonrakerClient(
+        moonraker_uri=moonraker_uri,
+        moonraker_api=moonraker_api_key,
+        printer_name=printer_name,
+        loop=loop
+    )
+    
+    # Create the data sync service
+    data_sync_service = DataSyncService(
+        jrpc=jrpc,
+        printer_name=printer_name,
+        loop=loop
+    )
+    
+    # Create the FCM client
+    fcm_client  = MobilerakerFcmClient(
+        # 'http://127.0.0.1:8080',
+        'https://mobileraker.eliteschw31n.de',
+        loop)
+    
+    # Create the default snapshot client (will be used as fallback)
+    snapshot_client = WebcamSnapshotClient(
+        uri_or_data=snapshot_uri,
+        rotation=snapshot_rotation
+    )
+    
+    # Create the MobilerakerCompanion
+    companion = MobilerakerCompanion(
+        jrpc=jrpc,
+        data_sync_service=data_sync_service,
+        fcm_client=fcm_client,
+        webcam_snapshot_client=snapshot_client,
+        printer_name=printer_name,
+        loop=loop,
+        companion_config=companion_config,
+        exclude_sensors=exclude_sensors
+    )
+    
+    logging.info("Starting MobilerakerCompanion for printer: %s", printer_name)
+    await companion.start()
+    
+    # Keep the task running
+    while True:
+        await asyncio.sleep(3600)  # Sleep for an hour and check again
 
 
-if __name__ == '__main__':
-    main()
+if __name__ == "__main__":
+    asyncio.run(main(sys.argv[1:]))

mobileraker/client/snapshot_client.py

@@ -0,0 +1,120 @@
+from io import BytesIO
+import logging
+from typing import Optional, Union
+
+from PIL import Image, ImageOps
+import requests
+
+from mobileraker.data.dtos.moonraker.webcam_data import WebcamData
+
+
+
+class WebcamSnapshotClient:
+    """
+    A client that captures and processes snapshots from a webcam.
+
+    Parameters:
+        uri_or_data (Union[str, WebcamData]): Either a URI string or WebcamData object.
+        base_url (str, optional): Base URL of the server to prepend for relative paths. Default is "http://localhost".
+        rotation (int, optional): Fallback rotation angle if URI is provided directly. Default is 0.
+
+    Attributes:
+        uri (str): The URI to fetch the snapshot from.
+        base_url (str): Base URL of the server for handling relative paths.
+        rotation (int): The rotation angle (in degrees) to apply to the captured snapshot.
+        flip_horizontal (bool): Whether to flip the image horizontally.
+        flip_vertical (bool): Whether to flip the image vertically.
+        logger (logging.Logger): The logger instance for logging messages.
+    """
+
+    def __init__(self, uri_or_data: Union[str, WebcamData], base_url: str = "http://localhost", rotation: int = 0) -> None:
+        self.base_url = base_url.rstrip('/')
+        
+        if isinstance(uri_or_data, WebcamData):
+            self.uri = self._normalize_uri(uri_or_data.snapshot_url)
+            self.rotation = uri_or_data.rotation
+            self.flip_horizontal = uri_or_data.flip_horizontal
+            self.flip_vertical = uri_or_data.flip_vertical
+            self.name = uri_or_data.name
+        else:
+            self.uri = self._normalize_uri(uri_or_data)
+            self.rotation = rotation
+            self.flip_horizontal = False
+            self.flip_vertical = False
+            self.name = "Unknown"
+            
+        self.logger = logging.getLogger('mobileraker.webcam')
+        
+    def _normalize_uri(self, uri: str) -> str:
+        """
+        Normalize the URI by adding base_url if it's a relative path.
+        
+        Args:
+            uri (str): The URI to normalize.
+            
+        Returns:
+            str: The normalized URI.
+        """
+        if not uri:
+            return ""
+            
+        # Check if the URI is already absolute
+        if uri.startswith(('http://', 'https://')):
+            return uri
+            
+        # Handle relative paths
+        if uri.startswith('/'):
+            return f"{self.base_url}{uri}"
+        else:
+            return f"{self.base_url}/{uri}"
+
+    def capture_snapshot(self, max_width: int = 1024, quality: int = 85) -> Optional[bytes]:
+        """
+        Captures and processes a snapshot from the webcam.
+
+        Args:
+            max_width (int): Maximum width for the image, will scale proportionally. Default is 1024.
+            quality (int): JPEG compression quality (1-100). Default is 85.
+
+        Returns:
+            Optional[bytes]: The processed snapshot image as bytes if successful, or None on failure.
+        """
+        self.logger.info("Capturing snapshot from webcam: %s at %s", self.name, self.uri)
+        try:
+            res = requests.get(self.uri, timeout=5)
+            res.raise_for_status()
+
+            image = Image.open(BytesIO(res.content)).convert("RGB")
+            
+            # Resize the image if width exceeds max_width
+            if image.width > max_width:
+                image = image.resize((max_width, int(image.height * (max_width / image.width))))
+            
+            # Apply transformations
+            if self.flip_horizontal:
+                image = ImageOps.mirror(image)
+            if self.flip_vertical:
+                image = ImageOps.flip(image)
+            if self.rotation:
+                image = image.rotate(self.rotation)
+                
+            # Convert to JPEG
+            buffered = BytesIO()
+            image.save(buffered, format="JPEG", optimize=True, quality=quality)
+            
+            self.logger.info(
+                "Snapshot captured successfully! Applied transformations: rotation=%i°, flip_h=%s, flip_v=%s", 
+                self.rotation, self.flip_horizontal, self.flip_vertical
+            )
+            return buffered.getvalue()
+            
+        except requests.exceptions.ConnectionError:
+            self.logger.error("Could not connect to webcam: %s", self.name)
+        except requests.exceptions.Timeout:
+            self.logger.error("Connection to webcam timed out: %s", self.name)
+        except requests.exceptions.RequestException as e:
+            self.logger.error("HTTP error while connecting to webcam: %s - %s", self.name, str(e))
+        except Exception as e:
+            self.logger.error("Error processing snapshot from %s: %s", self.name, str(e))
+            
+        return None