openadapt-tray 0.0.1__py3-none-any.whl

openadapt_tray/__init__.py

@@ -0,0 +1,16 @@
+"""OpenAdapt Tray - System tray application for OpenAdapt."""
+
+__version__ = "0.1.0"
+
+from openadapt_tray.app import TrayApplication, main
+from openadapt_tray.state import TrayState, AppState, StateManager
+from openadapt_tray.config import TrayConfig
+
+__all__ = [
+    "TrayApplication",
+    "TrayState",
+    "AppState",
+    "StateManager",
+    "TrayConfig",
+    "main",
+]

openadapt_tray/__main__.py

@@ -0,0 +1,10 @@
+"""Entry point for running openadapt_tray as a module.
+
+Usage:
+    python -m openadapt_tray
+"""
+
+from openadapt_tray.app import main
+
+if __name__ == "__main__":
+    main()

openadapt_tray/app.py

@@ -0,0 +1,336 @@
+"""Main system tray application for OpenAdapt."""
+
+import sys
+import threading
+import subprocess
+import webbrowser
+from typing import Optional
+
+import pystray
+from PIL import Image
+
+from openadapt_tray.state import StateManager, TrayState, AppState
+from openadapt_tray.menu import MenuBuilder
+from openadapt_tray.icons import IconManager
+from openadapt_tray.shortcuts import HotkeyManager
+from openadapt_tray.notifications import NotificationManager
+from openadapt_tray.ipc import IPCClient, IPCMessageType
+from openadapt_tray.config import TrayConfig
+from openadapt_tray.platform import get_platform_handler
+
+
+class TrayApplication:
+    """Main system tray application."""
+
+    def __init__(self, config: Optional[TrayConfig] = None):
+        """Initialize the tray application.
+
+        Args:
+            config: Optional configuration. If None, loads from file or defaults.
+        """
+        self.config = config or TrayConfig.load()
+        self.state = StateManager()
+        self.platform = get_platform_handler()
+
+        # Initialize components
+        self.icons = IconManager()
+        self.notifications = NotificationManager()
+        self.menu_builder = MenuBuilder(self)
+        self.hotkeys = HotkeyManager(self.config.hotkeys)
+        self.ipc = IPCClient()
+
+        # Process handle for capture subprocess
+        self._capture_process: Optional[subprocess.Popen] = None
+
+        # Create tray icon
+        self.icon = pystray.Icon(
+            name="openadapt",
+            icon=self.icons.get(TrayState.IDLE),
+            title="OpenAdapt",
+            menu=self.menu_builder.build(),
+        )
+
+        # Set tray icon reference for Windows notifications
+        self.notifications.set_tray_icon(self.icon)
+
+        # Register state change handler
+        self.state.add_listener(self._on_state_change)
+
+        # Register IPC handlers
+        self._setup_ipc_handlers()
+
+        # Register hotkey handlers
+        self._setup_hotkeys()
+
+    def _setup_hotkeys(self) -> None:
+        """Configure global hotkeys."""
+        self.hotkeys.register(
+            self.config.hotkeys.toggle_recording,
+            self._toggle_recording,
+        )
+        self.hotkeys.register(
+            self.config.hotkeys.open_dashboard,
+            self._open_dashboard,
+        )
+
+        # Register triple-ctrl for stop recording (legacy compatibility)
+        if self.config.stop_on_triple_ctrl:
+            self.hotkeys.register(
+                "<ctrl>+<ctrl>+<ctrl>",
+                self._stop_recording_if_active,
+            )
+
+    def _setup_ipc_handlers(self) -> None:
+        """Configure IPC message handlers."""
+        self.ipc.register_handler(
+            IPCMessageType.RECORDING_STARTED,
+            self._on_ipc_recording_started,
+        )
+        self.ipc.register_handler(
+            IPCMessageType.RECORDING_STOPPED,
+            self._on_ipc_recording_stopped,
+        )
+        self.ipc.register_handler(
+            IPCMessageType.RECORDING_ERROR,
+            self._on_ipc_recording_error,
+        )
+        self.ipc.register_handler(
+            IPCMessageType.STATUS_UPDATE,
+            self._on_ipc_status_update,
+        )
+        self.ipc.register_handler(
+            IPCMessageType.TRAINING_PROGRESS,
+            self._on_ipc_training_progress,
+        )
+
+    def _on_state_change(self, state: AppState) -> None:
+        """Handle state changes.
+
+        Args:
+            state: New application state.
+        """
+        # Update icon
+        self.icon.icon = self.icons.get(state.state)
+
+        # Update menu
+        self.icon.menu = self.menu_builder.build()
+
+        # Show notification if appropriate
+        if self.config.show_notifications:
+            self._show_state_notification(state)
+
+    def _show_state_notification(self, state: AppState) -> None:
+        """Show notification for state transitions.
+
+        Args:
+            state: Current application state.
+        """
+        messages = {
+            TrayState.RECORDING: (
+                "Recording Started",
+                f"Capturing: {state.current_capture or 'session'}",
+            ),
+            TrayState.IDLE: ("Recording Stopped", "Capture saved"),
+            TrayState.TRAINING: ("Training Started", "Model training in progress"),
+            TrayState.ERROR: ("Error", state.error_message or "An error occurred"),
+        }
+
+        if state.state in messages:
+            title, body = messages[state.state]
+            self.notifications.show(
+                title,
+                body,
+                duration_ms=self.config.notification_duration_ms,
+            )
+
+    def _toggle_recording(self) -> None:
+        """Toggle recording state."""
+        if self.state.current.can_start_recording():
+            self.start_recording()
+        elif self.state.current.can_stop_recording():
+            self.stop_recording()
+
+    def _stop_recording_if_active(self) -> None:
+        """Stop recording if currently active (for triple-ctrl)."""
+        if self.state.current.can_stop_recording():
+            self.stop_recording()
+
+    def start_recording(self, name: Optional[str] = None) -> None:
+        """Start a new capture session.
+
+        Args:
+            name: Optional name for the capture. If None, prompts user.
+        """
+        if not self.state.current.can_start_recording():
+            return
+
+        # Prompt for name if not provided
+        if name is None and self.config.use_native_dialogs:
+            name = self.platform.prompt_input(
+                "New Recording",
+                "Enter a name for this capture:",
+            )
+            if not name:
+                return  # User cancelled
+
+        # Use default name if still not set
+        if not name:
+            from datetime import datetime
+
+            name = datetime.now().strftime("capture_%Y%m%d_%H%M%S")
+
+        self.state.transition(TrayState.RECORDING_STARTING, current_capture=name)
+
+        # Start capture in background thread
+        threading.Thread(
+            target=self._run_capture,
+            args=(name,),
+            daemon=True,
+        ).start()
+
+    def _run_capture(self, name: str) -> None:
+        """Run capture in background thread.
+
+        Args:
+            name: Capture session name.
+        """
+        try:
+            # Start capture via CLI subprocess
+            self._capture_process = subprocess.Popen(
+                ["openadapt", "record", name],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            self.state.transition(TrayState.RECORDING, current_capture=name)
+
+            # Wait for process to complete (when stopped externally)
+            self._capture_process.wait()
+
+            # Check if we're still in recording state (vs explicit stop)
+            if self.state.current.state == TrayState.RECORDING:
+                self.state.transition(TrayState.IDLE)
+
+        except FileNotFoundError:
+            self.state.transition(
+                TrayState.ERROR,
+                error_message="openadapt CLI not found. Please install openadapt.",
+            )
+        except Exception as e:
+            self.state.transition(TrayState.ERROR, error_message=str(e))
+
+    def stop_recording(self) -> None:
+        """Stop the current capture session."""
+        if not self.state.current.can_stop_recording():
+            return
+
+        self.state.transition(TrayState.RECORDING_STOPPING)
+
+        # Terminate capture process
+        if self._capture_process and self._capture_process.poll() is None:
+            try:
+                # Send SIGTERM for graceful shutdown
+                self._capture_process.terminate()
+
+                # Wait briefly for process to cleanup
+                try:
+                    self._capture_process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    # Force kill if not responding
+                    self._capture_process.kill()
+            except Exception as e:
+                print(f"Error stopping capture process: {e}")
+
+        self._capture_process = None
+        self.state.transition(TrayState.IDLE)
+
+    def _open_dashboard(self) -> None:
+        """Open the web dashboard."""
+        webbrowser.open(f"http://localhost:{self.config.dashboard_port}")
+
+    # IPC event handlers
+
+    def _on_ipc_recording_started(self, message) -> None:
+        """Handle recording started IPC event."""
+        data = message.data or {}
+        self.state.transition(
+            TrayState.RECORDING,
+            current_capture=data.get("name"),
+        )
+
+    def _on_ipc_recording_stopped(self, message) -> None:
+        """Handle recording stopped IPC event."""
+        self.state.transition(TrayState.IDLE)
+
+    def _on_ipc_recording_error(self, message) -> None:
+        """Handle recording error IPC event."""
+        data = message.data or {}
+        self.state.transition(
+            TrayState.ERROR,
+            error_message=data.get("error", "Recording error"),
+        )
+
+    def _on_ipc_status_update(self, message) -> None:
+        """Handle status update IPC event."""
+        # Generic status updates - could update UI or log
+        pass
+
+    def _on_ipc_training_progress(self, message) -> None:
+        """Handle training progress IPC event."""
+        data = message.data or {}
+        progress = data.get("progress", 0)
+        self.state.transition(
+            TrayState.TRAINING,
+            training_progress=progress,
+        )
+
+    def run(self) -> None:
+        """Run the application."""
+        # Start hotkey listener
+        self.hotkeys.start()
+
+        # Platform-specific setup
+        self.platform.setup()
+
+        # Try to connect to IPC server (optional - won't block if unavailable)
+        try:
+            connected = self.ipc.connect()
+            if connected:
+                print("IPC connected successfully")
+            else:
+                print("IPC server not available - running in standalone mode")
+        except Exception as e:
+            print(f"IPC connection failed: {e} - running in standalone mode")
+
+        # Run the tray icon (blocks)
+        self.icon.run()
+
+    def quit(self) -> None:
+        """Quit the application."""
+        # Stop any active recording
+        if self.state.current.is_recording():
+            self.stop_recording()
+
+        # Cleanup components
+        self.hotkeys.stop()
+        self.ipc.close()
+        self.notifications.cleanup()
+        self.platform.cleanup()
+
+        # Stop tray icon
+        self.icon.stop()
+
+
+def main() -> None:
+    """Entry point for the tray application."""
+    app = TrayApplication()
+    try:
+        app.run()
+    except KeyboardInterrupt:
+        app.quit()
+    except Exception as e:
+        print(f"Fatal error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

openadapt_tray/config.py

@@ -0,0 +1,124 @@
+"""Configuration management for OpenAdapt Tray."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Any, Dict
+import json
+import os
+
+from openadapt_tray.shortcuts import HotkeyConfig
+
+
+@dataclass
+class TrayConfig:
+    """Tray application configuration."""
+
+    # Hotkeys
+    hotkeys: HotkeyConfig = field(default_factory=HotkeyConfig)
+
+    # Paths
+    captures_directory: str = "~/openadapt/captures"
+    training_output_directory: str = "~/openadapt/training"
+
+    # Dashboard
+    dashboard_port: int = 8080
+    auto_launch_dashboard: bool = True
+
+    # Behavior
+    auto_start_on_login: bool = False
+    minimize_to_tray: bool = True
+    show_notifications: bool = True
+    notification_duration_ms: int = 5000
+
+    # Recording
+    default_record_audio: bool = True
+    default_transcribe: bool = True
+    stop_on_triple_ctrl: bool = True
+
+    # Appearance
+    use_native_dialogs: bool = True
+
+    @classmethod
+    def config_path(cls) -> Path:
+        """Get configuration file path."""
+        # Use XDG_CONFIG_HOME on Linux, ~/Library/Application Support on macOS,
+        # %APPDATA% on Windows
+        if os.name == "nt":
+            base = Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
+        elif os.name == "posix":
+            if "darwin" in os.sys.platform:
+                base = Path.home() / "Library" / "Application Support"
+            else:
+                base = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
+        else:
+            base = Path.home() / ".config"
+
+        return base / "openadapt" / "tray.json"
+
+    @classmethod
+    def load(cls) -> "TrayConfig":
+        """Load configuration from file."""
+        path = cls.config_path()
+        if path.exists():
+            try:
+                data = json.loads(path.read_text())
+                return cls._from_dict(data)
+            except Exception as e:
+                print(f"Warning: Could not load config: {e}")
+        return cls()
+
+    @classmethod
+    def _from_dict(cls, data: Dict[str, Any]) -> "TrayConfig":
+        """Create a TrayConfig from a dictionary."""
+        hotkeys_data = data.pop("hotkeys", {})
+        hotkeys = HotkeyConfig(
+            toggle_recording=hotkeys_data.get(
+                "toggle_recording", HotkeyConfig.toggle_recording
+            ),
+            open_dashboard=hotkeys_data.get(
+                "open_dashboard", HotkeyConfig.open_dashboard
+            ),
+            stop_recording=hotkeys_data.get(
+                "stop_recording", HotkeyConfig.stop_recording
+            ),
+        )
+
+        return cls(hotkeys=hotkeys, **data)
+
+    def save(self) -> None:
+        """Save configuration to file."""
+        path = self.config_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        data = self.to_dict()
+        path.write_text(json.dumps(data, indent=2))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert configuration to a dictionary."""
+        return {
+            "hotkeys": {
+                "toggle_recording": self.hotkeys.toggle_recording,
+                "open_dashboard": self.hotkeys.open_dashboard,
+                "stop_recording": self.hotkeys.stop_recording,
+            },
+            "captures_directory": self.captures_directory,
+            "training_output_directory": self.training_output_directory,
+            "dashboard_port": self.dashboard_port,
+            "auto_launch_dashboard": self.auto_launch_dashboard,
+            "auto_start_on_login": self.auto_start_on_login,
+            "minimize_to_tray": self.minimize_to_tray,
+            "show_notifications": self.show_notifications,
+            "notification_duration_ms": self.notification_duration_ms,
+            "default_record_audio": self.default_record_audio,
+            "default_transcribe": self.default_transcribe,
+            "stop_on_triple_ctrl": self.stop_on_triple_ctrl,
+            "use_native_dialogs": self.use_native_dialogs,
+        }
+
+    def get_captures_path(self) -> Path:
+        """Get the expanded captures directory path."""
+        return Path(self.captures_directory).expanduser()
+
+    def get_training_path(self) -> Path:
+        """Get the expanded training output directory path."""
+        return Path(self.training_output_directory).expanduser()

openadapt_tray/icons.py

@@ -0,0 +1,171 @@
+"""Icon management for OpenAdapt Tray."""
+
+from pathlib import Path
+from typing import Optional, Dict
+import sys
+
+from PIL import Image
+
+from openadapt_tray.state import TrayState
+
+
+class IconManager:
+    """Manages loading and caching of tray icons."""
+
+    # State to icon filename mapping
+    STATE_ICONS: Dict[TrayState, str] = {
+        TrayState.IDLE: "idle.png",
+        TrayState.RECORDING_STARTING: "recording.png",
+        TrayState.RECORDING: "recording.png",
+        TrayState.RECORDING_STOPPING: "recording.png",
+        TrayState.TRAINING: "training.png",
+        TrayState.TRAINING_PAUSED: "training.png",
+        TrayState.ERROR: "error.png",
+    }
+
+    # Icon colors for fallback generation
+    STATE_COLORS: Dict[TrayState, str] = {
+        TrayState.IDLE: "#4A90D9",  # Blue
+        TrayState.RECORDING_STARTING: "#F5A623",  # Yellow/Orange
+        TrayState.RECORDING: "#D0021B",  # Red
+        TrayState.RECORDING_STOPPING: "#F5A623",  # Yellow/Orange
+        TrayState.TRAINING: "#7B68EE",  # Purple
+        TrayState.TRAINING_PAUSED: "#9B59B6",  # Lighter Purple
+        TrayState.ERROR: "#D0021B",  # Red
+    }
+
+    def __init__(self, assets_dir: Optional[Path] = None):
+        """Initialize the icon manager.
+
+        Args:
+            assets_dir: Path to the assets directory. If None, uses package assets.
+        """
+        if assets_dir is None:
+            # Find assets directory relative to this module
+            module_dir = Path(__file__).parent
+            assets_dir = module_dir.parent.parent / "assets" / "icons"
+
+        self.assets_dir = assets_dir
+        self._cache: Dict[str, Image.Image] = {}
+        self._retina_scale = self._detect_retina()
+
+    def _detect_retina(self) -> int:
+        """Detect if we're on a retina/HiDPI display."""
+        if sys.platform == "darwin":
+            # On macOS, assume retina by default for newer systems
+            return 2
+        return 1
+
+    def get(self, state: TrayState) -> Image.Image:
+        """Get the icon for a given state.
+
+        Args:
+            state: The application state.
+
+        Returns:
+            PIL Image for the icon.
+        """
+        icon_name = self.STATE_ICONS.get(state, "idle.png")
+
+        # Check cache first
+        cache_key = f"{icon_name}_{self._retina_scale}"
+        if cache_key in self._cache:
+            return self._cache[cache_key]
+
+        # Try to load icon file
+        icon = self._load_icon(icon_name)
+        if icon is None:
+            # Generate fallback icon
+            icon = self._generate_fallback(state)
+
+        self._cache[cache_key] = icon
+        return icon
+
+    def _load_icon(self, icon_name: str) -> Optional[Image.Image]:
+        """Try to load an icon from the assets directory.
+
+        Args:
+            icon_name: The icon filename.
+
+        Returns:
+            PIL Image if found, None otherwise.
+        """
+        if not self.assets_dir.exists():
+            return None
+
+        # Try retina version first on HiDPI displays
+        if self._retina_scale > 1:
+            retina_name = icon_name.replace(".png", "@2x.png")
+            retina_path = self.assets_dir / retina_name
+            if retina_path.exists():
+                try:
+                    return Image.open(retina_path)
+                except Exception:
+                    pass
+
+        # Try regular version
+        icon_path = self.assets_dir / icon_name
+        if icon_path.exists():
+            try:
+                return Image.open(icon_path)
+            except Exception:
+                pass
+
+        return None
+
+    def _generate_fallback(self, state: TrayState, size: int = 64) -> Image.Image:
+        """Generate a simple colored square icon as fallback.
+
+        Args:
+            state: The application state.
+            size: The icon size in pixels.
+
+        Returns:
+            Generated PIL Image.
+        """
+        color = self.STATE_COLORS.get(state, "#4A90D9")
+        return self.create_colored_icon(color, size)
+
+    @staticmethod
+    def create_colored_icon(color: str, size: int = 64) -> Image.Image:
+        """Create a simple colored square icon.
+
+        Args:
+            color: Hex color string (e.g., "#FF0000").
+            size: Icon size in pixels.
+
+        Returns:
+            PIL Image with the specified color.
+        """
+        # Create RGBA image with rounded corners effect
+        image = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+
+        # Parse hex color
+        if color.startswith("#"):
+            color = color[1:]
+        r = int(color[0:2], 16)
+        g = int(color[2:4], 16)
+        b = int(color[4:6], 16)
+
+        # Draw a filled circle for a cleaner look
+        from PIL import ImageDraw
+
+        draw = ImageDraw.Draw(image)
+
+        # Draw circle with slight padding
+        padding = size // 8
+        draw.ellipse(
+            [padding, padding, size - padding, size - padding],
+            fill=(r, g, b, 255),
+        )
+
+        return image
+
+    def clear_cache(self) -> None:
+        """Clear the icon cache."""
+        self._cache.clear()
+
+    def preload_all(self) -> None:
+        """Preload all state icons into cache."""
+        for state in TrayState:
+            self.get(state)