release getting mac to work first try

Author: tom

README_macOS.md

@@ -6,18 +6,21 @@ Detailed macOS-specific setup for **PyCron Video Alarm Manager**.
 
 ## 📦 Prerequisites
 
-1. **MPV or VLC Media Player**: Required for reliable media playback.
-   - Install via Homebrew: 
-     ```bash
-     brew install mpv
-     ```
-     or
-     ```bash
-     brew install --cask vlc
-     ```
+1. **VLC Media Player** *(required for video/audio playback)*:
+   ```bash
+   brew install --cask vlc
+   ```
 
 2. **Python 3**:
-   - Install via Homebrew: `brew install python`
+   ```bash
+   brew install python
+   ```
+
+3. **brightness CLI** *(optional — only needed if your sequences use a `set_brightness` action)*:
+   ```bash
+   brew install brightness
+   ```
+   Without it, brightness actions are silently skipped.
 
 ## 🚀 Setting Up the Application
 

src/core/factory.py

@@ -23,6 +23,15 @@ def get_platform_managers() -> tuple[PowerManager, DisplayManager]:
         except ImportError as e:
             logging.error(f"Failed to import Linux managers: {e}")
             raise
-    
+
+    elif sys.platform == "darwin":
+        try:
+            from platforms.macos.power import MacOSPowerManager
+            from platforms.macos.display import MacOSDisplayManager
+            return MacOSPowerManager(), MacOSDisplayManager()
+        except ImportError as e:
+            logging.error(f"Failed to import macOS managers: {e}")
+            raise
+
     else:
         raise NotImplementedError(f"Platform {sys.platform} is not supported.")

src/logic/media_utils.py

@@ -51,7 +51,7 @@ def play_audio_with_retry(file_path, duration=None, gain=0, system_volume=None,
 
 def get_player_priority(file_path):
     """Get the preferred player."""
-    if sys.platform == "win32":
+    if sys.platform in ("win32", "darwin"):
         return ["vlc"]
     return ["mpv"]
 
@@ -65,7 +65,7 @@ def execute_media(file_path, config=None):
 
     success = False
     try:
-        if sys.platform == "win32":
+        if sys.platform in ("win32", "darwin"):
             success = play_video_vlc(file_path, config)
             player_name = "vlc"
         else:
@@ -86,24 +86,29 @@ def execute_media(file_path, config=None):
 execute_video = execute_media
 
 def get_vlc_path():
-    """Find the VLC executable natively on Windows."""
+    """Find the VLC executable on Windows or macOS."""
     vlc_path = shutil.which("vlc")
     if vlc_path:
         return vlc_path
-        
+
     if sys.platform == "win32":
         program_files = os.environ.get("ProgramFiles", "C:\\Program Files")
         program_files_x86 = os.environ.get("ProgramFiles(x86)", "C:\\Program Files (x86)")
-        
+
         fallbacks = [
             os.path.join(program_files, "VideoLAN", "VLC", "vlc.exe"),
             os.path.join(program_files_x86, "VideoLAN", "VLC", "vlc.exe")
         ]
-        
+
         for path in fallbacks:
             if path and os.path.isfile(path) and os.access(path, os.X_OK):
                 return path
-                
+
+    elif sys.platform == "darwin":
+        mac_vlc = "/Applications/VLC.app/Contents/MacOS/VLC"
+        if os.path.isfile(mac_vlc) and os.access(mac_vlc, os.X_OK):
+            return mac_vlc
+
     return None
 
 def get_mpv_path():
@@ -112,24 +117,24 @@ def get_mpv_path():
 
 def check_media_player_installed():
     """Verify strictly if the native media player is installed."""
-    if sys.platform == "win32":
+    if sys.platform in ("win32", "darwin"):
         return get_vlc_path() is not None
     return get_mpv_path() is not None
 
 def detect_available_players():
     """
     Detect which video players are installed on the system.
-    Returns: ['vlc'] on Windows, ['mpv'] on Linux.
+    Returns: ['vlc'] on Windows/macOS, ['mpv'] on Linux.
     """
     available = []
-    
-    if sys.platform == "win32":
+
+    if sys.platform in ("win32", "darwin"):
         if get_vlc_path():
             available.append("vlc")
     else:
         if get_mpv_path():
             available.append("mpv")
-            
+
     return available
 
 def play_video_vlc(file_path, config=None):

src/logic/scheduler.py

@@ -21,6 +21,12 @@ def __init__(self):
                 self.platform_scheduler = WindowsScheduler()
             except ImportError as e:
                 logging.error(f"Failed to load Windows Scheduler: {e}")
+        elif sys.platform == "darwin":
+            try:
+                from platforms.macos.scheduler import MacOSScheduler
+                self.platform_scheduler = MacOSScheduler()
+            except ImportError as e:
+                logging.error(f"Failed to load macOS Scheduler: {e}")
         else:
             logging.error(f"Unsupported platform for scheduling: {sys.platform}")
 

src/main.py

@@ -62,9 +62,13 @@ def main():
 
         # Determine project root — different for frozen (PyInstaller) vs development
         if getattr(sys, 'frozen', False):
-            # Frozen: executable lives in dist/ or alongside sequences/
-            # Use the directory containing the executable, NOT sys._MEIPASS
-            project_root = os.path.dirname(os.path.abspath(sys.executable))
+            # Frozen: executable lives in dist/ (Linux/Win) or App.app/Contents/MacOS/ (macOS)
+            exe_path = os.path.abspath(sys.executable)
+            if sys.platform == 'darwin' and '.app/Contents/MacOS' in exe_path:
+                # Walk up: MacOS -> Contents -> App.app -> parent folder (where video/, audio/ live)
+                project_root = os.path.dirname(os.path.dirname(os.path.dirname(exe_path)))
+            else:
+                project_root = os.path.dirname(exe_path)
         else:
             # Development: src/main.py → project root is one level up
             project_root = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
@@ -123,7 +127,7 @@ def main():
                 logging.info(f"Attempting to delete one-time cron job for '{args.execute_sequence}'...")
                 try:
                     import os
-                    if sys.platform.startswith('linux'):
+                    if sys.platform.startswith('linux') or sys.platform == 'darwin':
                         # Directly remove the cron job by matching our unique ID + marker
                         try:
                             from crontab import CronTab

src/platforms/macos/__init__.py

@@ -0,0 +1,83 @@
+import subprocess
+import logging
+from core.interfaces import DisplayManager
+
+
+class MacOSDisplayManager(DisplayManager):
+    """macOS display manager.
+
+    Brightness control requires the 'brightness' CLI tool:
+        brew install brightness
+
+    If it is not installed, brightness calls log a warning and return False
+    silently — no crash, no error dialog.
+
+    Display sleep / wake uses pmset which ships with macOS.
+    """
+
+    def _run(self, cmd):
+        """Run a command. Returns True on success."""
+        try:
+            subprocess.run(cmd, check=True, capture_output=True)
+            return True
+        except subprocess.CalledProcessError as e:
+            logging.debug(f"Command failed: {' '.join(cmd)} — {e}")
+            return False
+        except FileNotFoundError:
+            logging.debug(f"Command not found: {cmd[0]}")
+            return False
+
+    # ------------------------------------------------------------------
+    # Display power
+    # ------------------------------------------------------------------
+
+    def turn_off(self) -> bool:
+        """Put the display to sleep immediately."""
+        return self._run(["pmset", "displaysleepnow"])
+
+    def turn_on(self) -> bool:
+        """Wake the display (brief caffeinate wakeup assertion)."""
+        return self._run(["caffeinate", "-u", "-t", "1"])
+
+    # ------------------------------------------------------------------
+    # Brightness
+    # ------------------------------------------------------------------
+
+    def set_brightness(self, level: int) -> bool:
+        """Set screen brightness (0-100) via the 'brightness' Homebrew CLI.
+
+        If 'brightness' is not installed the call returns False and logs a
+        warning — it does NOT raise an exception or show an error dialog.
+
+        Install with: brew install brightness
+        """
+        level = max(0, min(100, int(level)))
+        brightness_val = f"{level / 100.0:.2f}"
+
+        if self._run(["brightness", brightness_val]):
+            logging.info(f"Brightness set to {level}% via 'brightness' CLI")
+            return True
+
+        logging.warning(
+            "macOS brightness control unavailable. "
+            "Install with: brew install brightness"
+        )
+        return False
+
+    def get_brightness(self) -> int:
+        """Get current brightness (0-100) via the 'brightness' CLI."""
+        try:
+            result = subprocess.run(
+                ["brightness", "-l"],
+                capture_output=True,
+                text=True
+            )
+            # Output contains lines like: "display 0: brightness 0.7500"
+            for line in result.stdout.splitlines():
+                if "brightness" in line:
+                    parts = line.strip().split()
+                    val = float(parts[-1])
+                    return int(val * 100)
+        except Exception:
+            pass
+        return 100  # Safe default

src/platforms/macos/display.py

@@ -0,0 +1,54 @@
+import subprocess
+import logging
+from core.interfaces import PowerManager
+
+
+class MacOSPowerManager(PowerManager):
+    """macOS power manager using caffeinate to inhibit sleep.
+
+    caffeinate ships with macOS — no installation required.
+
+    Flags used:
+        -d  Prevent display from sleeping
+        -i  Prevent system idle sleep
+        -m  Prevent disk from sleeping
+        -s  Prevent system sleep (AC power)
+    """
+
+    def __init__(self):
+        self._caffeinate_proc = None
+
+    def inhibit_sleep(self, reason: str = "Video Alarm Active") -> bool:
+        """Start caffeinate as a background process to block sleep."""
+        if self._caffeinate_proc and self._caffeinate_proc.poll() is None:
+            logging.info("Sleep already inhibited via caffeinate")
+            return True
+        try:
+            self._caffeinate_proc = subprocess.Popen(
+                ["caffeinate", "-d", "-i", "-m", "-s"],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL
+            )
+            logging.info(f"Sleep inhibited via caffeinate (pid {self._caffeinate_proc.pid})")
+            return True
+        except Exception as e:
+            logging.error(f"Failed to start caffeinate: {e}")
+            return False
+
+    def uninhibit_sleep(self) -> bool:
+        """Terminate caffeinate to allow sleep again."""
+        if self._caffeinate_proc:
+            try:
+                self._caffeinate_proc.terminate()
+                self._caffeinate_proc.wait(timeout=5)
+                logging.info("Released sleep inhibit (caffeinate terminated)")
+            except Exception as e:
+                logging.error(f"Failed to terminate caffeinate: {e}")
+                try:
+                    self._caffeinate_proc.kill()
+                except Exception:
+                    pass
+                return False
+            finally:
+                self._caffeinate_proc = None
+        return True