lemonade-sdk 8.1.9__py3-none-any.whl → 8.1.11__py3-none-any.whl

lemonade/tools/server/tray.py

@@ -7,11 +7,28 @@ import webbrowser
 from pathlib import Path
 import logging
 import tempfile
+import platform
+
 import requests
 from packaging.version import parse as parse_version
 
+from lemonade_server.pydantic_models import DEFAULT_CTX_SIZE
+
 from lemonade.version import __version__
-from lemonade.tools.server.utils.system_tray import SystemTray, Menu, MenuItem
+
+# Import the appropriate tray implementation based on platform
+if platform.system() == "Darwin":  # macOS
+    from lemonade.tools.server.utils.macos_tray import (
+        MacOSSystemTray as SystemTray,
+        Menu,
+        MenuItem,
+    )
+else:  # Windows/Linux
+    from lemonade.tools.server.utils.windows_tray import (
+        SystemTray,
+        Menu,
+        MenuItem,
+    )
 
 
 class OutputDuplicator:
@@ -57,6 +74,7 @@ class LemonadeTray(SystemTray):
         self.executor = ThreadPoolExecutor(max_workers=1)
         self.log_file = log_file
         self.port = port
+        self.ctx_size = DEFAULT_CTX_SIZE
         self.server_factory = server_factory
         self.debug_logs_enabled = log_level == "debug"
 
@@ -83,6 +101,9 @@ class LemonadeTray(SystemTray):
         self.version_check_thread = None
         self.stop_version_check = threading.Event()
 
+        # Hook function for platform-specific initialization callback
+        self.on_ready = None
+
     def get_latest_version(self):
         """
         Update the latest version information.
@@ -187,15 +208,38 @@ class LemonadeTray(SystemTray):
         Show the log file in a new window.
         """
         try:
-            subprocess.Popen(
-                [
-                    "powershell",
-                    "Start-Process",
-                    "powershell",
-                    "-ArgumentList",
-                    f'"-NoExit", "Get-Content -Wait {self.log_file}"',
-                ]
-            )
+            system = platform.system().lower()
+            if system == "darwin":
+                # Use Terminal.app to show live logs on macOS
+                try:
+                    subprocess.Popen(
+                        [
+                            "osascript",
+                            "-e",
+                            f'tell application "Terminal" to do script "tail -f {self.log_file}"',
+                        ]
+                    )
+                except (subprocess.CalledProcessError, FileNotFoundError) as e:
+                    self.logger.error(f"Failed to open Terminal for logs: {e}")
+                    self.show_balloon_notification(
+                        "Error",
+                        f"Failed to open logs in Terminal. Log file: {self.log_file}",
+                    )
+            elif system == "windows":
+                # Use PowerShell on Windows
+                subprocess.Popen(
+                    [
+                        "powershell",
+                        "Start-Process",
+                        "powershell",
+                        "-ArgumentList",
+                        f'"-NoExit", "Get-Content -Wait {self.log_file}"',
+                    ]
+                )
+            else:
+                # Unsupported platform
+                self.logger.error(f"Log viewing not supported on platform: {system}")
+
         except Exception as e:  # pylint: disable=broad-exception-caught
             self.logger.error(f"Error opening logs: {str(e)}")
 
@@ -224,7 +268,7 @@ class LemonadeTray(SystemTray):
         try:
             response = requests.get(
                 f"http://localhost:{self.port}/api/v0/health",
-                timeout=0.1,  # Add timeout
+                timeout=0.1,
             )
             response.raise_for_status()
             response_data = response.json()
@@ -253,7 +297,9 @@ class LemonadeTray(SystemTray):
         """
         Change the server port and restart the server.
         """
+
         try:
+
             # Stop the current server
             if self.server_thread and self.server_thread.is_alive():
                 # Set should_exit flag on the uvicorn server instance
@@ -266,22 +312,58 @@ class LemonadeTray(SystemTray):
 
             # Update the port in both the tray and the server instance
             self.port = new_port
-            if self.server:
-                self.server.port = new_port
 
-            # Restart the server
+            # Clear the old server instance to ensure a fresh start
+            # This prevents middleware conflicts when restarting
+            self.server = None
+
             self.server_thread = threading.Thread(target=self.start_server, daemon=True)
             self.server_thread.start()
 
-            # Show notification
             self.show_balloon_notification(
-                "Port Changed", f"Lemonade Server is now running on port {self.port}"
+                "Port Changed",
+                f"Lemonade Server is now running on port {self.port}",
             )
 
         except Exception as e:  # pylint: disable=broad-exception-caught
             self.logger.error(f"Error changing port: {str(e)}")
             self.show_balloon_notification("Error", f"Failed to change port: {str(e)}")
 
+    def change_context_size(self, _, __, new_ctx_size):
+        """
+        Change the server context size and restart the server.
+        """
+        try:
+            # Stop the current server
+            if self.server_thread and self.server_thread.is_alive():
+                # Set should_exit flag on the uvicorn server instance
+                if (
+                    hasattr(self.server, "uvicorn_server")
+                    and self.server.uvicorn_server
+                ):
+                    self.server.uvicorn_server.should_exit = True
+                self.server_thread.join(timeout=2)
+            # Update the context size in both the tray and the server instance
+            self.ctx_size = new_ctx_size
+            if self.server:
+                self.server.ctx_size = new_ctx_size
+            # Restart the server
+            self.server_thread = threading.Thread(target=self.start_server, daemon=True)
+            self.server_thread.start()
+            # Show notification
+            ctx_size_label = (
+                f"{new_ctx_size//1024}K" if new_ctx_size >= 1024 else str(new_ctx_size)
+            )
+            self.show_balloon_notification(
+                "Context Size Changed",
+                f"Lemonade Server context size is now {ctx_size_label}",
+            )
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            self.logger.error(f"Error changing context size: {str(e)}")
+            self.show_balloon_notification(
+                "Error", f"Failed to change context size: {str(e)}"
+            )
+
     def _using_installer(self):
         """
         Check if the user is using the NSIS installer by checking for embeddable python
@@ -438,6 +520,30 @@ class LemonadeTray(SystemTray):
 
         port_submenu = Menu(*port_menu_items)
 
+        # Create context size selection submenu with 6 options
+        ctx_size_menu_items = []
+        ctx_size_options = [
+            ("4K", 4096),
+            ("8K", 8192),
+            ("16K", 16384),
+            ("32K", 32768),
+            ("64K", 65536),
+            ("128K", 131072),
+        ]
+
+        for ctx_label, ctx_value in ctx_size_options:
+            # Create a function that returns the lambda to properly capture the ctx_size variable
+            def create_ctx_handler(ctx_size):
+                return lambda icon, item: self.change_context_size(icon, item, ctx_size)
+
+            ctx_item = MenuItem(
+                f"Context size {ctx_label}", create_ctx_handler(ctx_value)
+            )
+            ctx_item.checked = ctx_value == self.ctx_size
+            ctx_size_menu_items.append(ctx_item)
+
+        ctx_size_submenu = Menu(*ctx_size_menu_items)
+
         # Create the Logs submenu
         debug_log_text = "Enable Debug Logs"
         debug_log_item = MenuItem(debug_log_text, self.toggle_debug_logs)
@@ -452,6 +558,7 @@ class LemonadeTray(SystemTray):
         if status_successfully_checked:
             items.append(MenuItem("Load Model", None, submenu=load_submenu))
         items.append(MenuItem("Port", None, submenu=port_submenu))
+        items.append(MenuItem("Context Size", None, submenu=ctx_size_submenu))
         items.append(Menu.SEPARATOR)
 
         # Only show upgrade option if newer version is available
@@ -475,6 +582,11 @@ class LemonadeTray(SystemTray):
         Start the uvicorn server.
         """
         self.server = self.server_factory()
+
+        # Ensure the server uses the current port from the tray
+        # This is important when changing ports
+        self.server.port = self.port
+
         self.server.uvicorn_server = self.server.run_in_thread(self.server.host)
         self.server.uvicorn_server.run()
 
@@ -483,16 +595,6 @@ class LemonadeTray(SystemTray):
         Run the Lemonade tray application.
         """
 
-        # Register window class and create window
-        self.register_window_class()
-        self.create_window()
-
-        # Set up Windows console control handler for CTRL+C
-        self.console_handler = self.setup_console_control_handler(self.logger)
-
-        # Add tray icon
-        self.add_tray_icon()
-
         # Start the background model mapping update thread
         self.model_update_thread = threading.Thread(
             target=self.update_downloaded_models_background, daemon=True
@@ -509,17 +611,27 @@ class LemonadeTray(SystemTray):
         self.server_thread = threading.Thread(target=self.start_server, daemon=True)
         self.server_thread.start()
 
-        # Show initial notification
-        self.show_balloon_notification(
-            "Woohoo!",
-            (
-                "Lemonade Server is running! "
-                "Right-click the tray icon below to access options."
-            ),
-        )
+        # Provide an on_ready hook that Windows base tray will call after
+        # the HWND/icon are created. macOS will call it immediately after run.
+        def _on_ready():
+            system = platform.system().lower()
+            if system == "darwin":
+                message = (
+                    "Lemonade Server is running! "
+                    "Click the tray icon above to access options."
+                )
+            else:  # Windows/Linux
+                message = (
+                    "Lemonade Server is running! "
+                    "Right-click the tray icon below to access options."
+                )
+            self.show_balloon_notification("Woohoo!", message)
 
-        # Run the message loop in the main thread
-        self.message_loop()
+        # Attach hook for both implementations to invoke after init
+        self.on_ready = _on_ready
+
+        # Call the parent run method which handles platform-specific initialization
+        super().run()
 
     def exit_app(self, icon, item):
         """
@@ -534,8 +646,16 @@ class LemonadeTray(SystemTray):
         if self.version_check_thread and self.version_check_thread.is_alive():
             self.version_check_thread.join(timeout=1)
 
-        # Call parent exit method
-        super().exit_app(icon, item)
+        # Platform-specific exit handling
+        system = platform.system().lower()
+        if system == "darwin":  # macOS
+            # For macOS, quit the rumps application
+            import rumps
+
+            rumps.quit_application()
+        else:
+            # Call parent exit method for Windows
+            super().exit_app(icon, item)
 
         # Stop the server using the CLI stop command to ensure a rigorous cleanup
         # This must be a subprocess to ensure the cleanup doesnt kill itself

lemonade/tools/server/utils/macos_tray.py

@@ -0,0 +1,226 @@
+import platform
+import subprocess
+from typing import Callable, Optional
+
+# Check if we're on macOS and import accordingly
+if platform.system() == "Darwin":
+    try:
+        import rumps
+
+        RUMPS_AVAILABLE = True
+    except ImportError:
+        RUMPS_AVAILABLE = False
+        print("Warning: rumps not available. Install with: pip install rumps")
+else:
+    RUMPS_AVAILABLE = False
+
+
+class MenuItem:
+    """
+    Cross-platform menu item representation.
+    """
+
+    def __init__(
+        self,
+        text: str,
+        callback: Optional[Callable] = None,
+        enabled: bool = True,
+        submenu=None,
+        checked: bool = False,
+    ):
+        self.text = text
+        self.callback = callback
+        self.enabled = enabled
+        self.submenu = submenu
+        self.checked = checked
+
+
+class Menu:
+    """
+    Cross-platform menu representation.
+    """
+
+    SEPARATOR = "SEPARATOR"
+
+    def __init__(self, *items):
+        self.items = list(items)
+
+
+class MacOSSystemTray:
+    """
+    macOS-specific system tray implementation using rumps.
+    """
+
+    def __init__(self, app_name: str, icon_path: str):
+        self._check_rumps_availability()
+
+        self.app_name = app_name
+        self.icon_path = icon_path
+        self.app = None
+        self.menu_callbacks = {}
+        self._menu_update_timer = None
+
+    def _check_rumps_availability(self):
+        """Check if rumps is available and raise error if not."""
+        if not RUMPS_AVAILABLE:
+            raise ImportError("rumps library is required for macOS tray support")
+
+    def create_menu(self):
+        """
+        Create the context menu based on current state. Override in subclass.
+        """
+        return Menu(MenuItem("Exit", self.exit_app))
+
+    def build_rumps_menu(self, menu_items):
+        """
+        Convert our menu structure to rumps menu items.
+        """
+        rumps_items = []
+
+        for item in menu_items:
+            if item == Menu.SEPARATOR:
+                rumps_items.append(rumps.separator)
+            elif isinstance(item, MenuItem):
+                if item.submenu:
+                    # Create submenu
+                    submenu_items = self.build_rumps_menu(item.submenu.items)
+                    submenu = rumps.MenuItem(item.text)
+                    for sub_item in submenu_items:
+                        submenu.add(sub_item)
+                    rumps_items.append(submenu)
+                else:
+                    # Create regular menu item
+                    menu_item = rumps.MenuItem(
+                        item.text,
+                        callback=(
+                            self._create_callback_wrapper(item)
+                            if item.callback
+                            else None
+                        ),
+                    )
+
+                    # Set enabled state
+                    if not item.enabled:
+                        menu_item.set_callback(None)
+
+                    # Set checked state
+                    if item.checked:
+                        menu_item.state = 1
+                    else:
+                        menu_item.state = 0
+
+                    rumps_items.append(menu_item)
+
+        return rumps_items
+
+    def _create_callback_wrapper(self, item):
+        """Create a callback wrapper that matches our interface."""
+
+        def wrapper(sender):  # pylint: disable=unused-argument
+            if item.callback:
+                item.callback(None, item)
+
+        return wrapper
+
+    def show_balloon_notification(
+        self, title, message, timeout=5000
+    ):  # pylint: disable=unused-argument
+        """
+        Show a notification on macOS using the Notification Center.
+        Falls back to console output if AppleScript fails.
+        """
+        try:
+            # Escape quotes in message and title for AppleScript
+            escaped_title = title.replace('"', '\\"')
+            escaped_message = message.replace('"', '\\"')
+            escaped_app_name = self.app_name.replace('"', '\\"')
+
+            # Use AppleScript to show notification
+            script = (
+                f'display notification "{escaped_message}" '
+                f'with title "{escaped_title}" subtitle "{escaped_app_name}"'
+            )
+            subprocess.run(
+                ["osascript", "-e", script], check=True, capture_output=True, text=True
+            )
+        except FileNotFoundError:
+            # osascript not available, fallback to console
+            print(f"[{self.app_name}] {title}: {message}")
+        except subprocess.CalledProcessError as e:
+            # AppleScript failed, fallback to console
+            print(f"[{self.app_name}] {title}: {message}")
+            print(f"Warning: Failed to show notification via AppleScript: {e}")
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            # Any other error, fallback to console
+            print(f"[{self.app_name}] {title}: {message}")
+            print(f"Warning: Failed to show notification: {e}")
+
+    def exit_app(self, _, __):
+        """Exit the application."""
+        if self.app:
+            rumps.quit_application()
+
+    def run(self):
+        """
+        Run the tray application.
+        """
+        self._check_rumps_availability()
+
+        try:
+            # Create the rumps app
+            self.app = rumps.App(self.app_name, icon=self.icon_path, quit_button=None)
+
+            # Build the initial menu
+            self.refresh_menu()
+
+            # Set up a timer to refresh menu periodically (every 3 seconds)
+            # This provides a good balance between responsiveness and performance
+            self._setup_menu_refresh_timer()
+
+            # Call the on_ready hook if available (for compatibility with tray.py)
+            if hasattr(self, "on_ready") and callable(getattr(self, "on_ready", None)):
+                getattr(self, "on_ready")()
+
+            # Start the app
+            self.app.run()
+        except Exception as e:
+            raise RuntimeError(f"Failed to start macOS tray application: {e}") from e
+
+    def refresh_menu(self):
+        """
+        Refresh the menu by rebuilding it with current state.
+        """
+        if not self.app:
+            return
+
+        # Clear existing menu
+        self.app.menu.clear()
+
+        # Build fresh menu with current state
+        menu = self.create_menu()
+        menu_items = self.build_rumps_menu(menu.items)
+
+        # Add updated menu items
+        for item in menu_items:
+            self.app.menu.add(item)
+
+    def _setup_menu_refresh_timer(self):
+        """
+        Set up a timer to periodically refresh the menu.
+        """
+        if not self.app:
+            return
+
+        # Create a timer that refreshes the menu every 3 seconds
+        @rumps.timer(3)
+        def refresh_menu_timer(sender):  # pylint: disable=unused-argument
+            self.refresh_menu()
+
+        # Store reference to prevent garbage collection
+        self._menu_update_timer = refresh_menu_timer
+
+    def update_menu(self):
+        """
+        Update the menu by rebuilding it.
+        """
+        self.refresh_menu()

lemonade/tools/server/utils/{system_tray.py → windows_tray.py}

@@ -25,12 +25,14 @@ class MenuItem:
         enabled: bool = True,
         submenu=None,
         bitmap_path: Optional[str] = None,
+        checked: bool = False,
     ):
         self.text = text
         self.callback = callback
         self.enabled = enabled
         self.submenu = submenu
         self.bitmap_path = bitmap_path
+        self.checked = checked
         self.id = None  # Will be set when menu is created
         self.bitmap_handle = None
 
@@ -358,9 +360,20 @@ class SystemTray:
         self.register_window_class()
         self.create_window()
 
+        # Set up Windows console control handler for CTRL+C
+        self.console_handler = self.setup_console_control_handler(self.logger)
+
         # Add tray icon
         self.add_tray_icon()
 
+        # Notify subclasses that the tray is ready (hwnd and icon created)
+        # Allows showing initial notifications after initialization
+        try:
+            if hasattr(self, "on_ready") and callable(getattr(self, "on_ready")):
+                self.on_ready()
+        except Exception:
+            pass
+
         # Run the message loop in the main thread
         self.message_loop()
 

lemonade/tools/server/webapp.py

@@ -1,5 +1,6 @@
 from pathlib import Path
 import json
+import platform
 from fastapi.responses import HTMLResponse
 from lemonade_server.model_manager import ModelManager
 
@@ -14,10 +15,11 @@ def get_webapp_html(port=8000):
     # Use shared filter function from model_manager.py
     filtered_models = ModelManager().filter_models_by_backend(server_models)
 
-    # Pass filtered server_models to JS
+    # Pass filtered server_models and platform info to JS
     server_models_js = (
         f"<script>window.SERVER_MODELS = {json.dumps(filtered_models)};</script>"
     )
+    platform_js = f"<script>window.PLATFORM = '{platform.system()}';</script>"
 
     # Load HTML template
     template_path = Path(__file__).parent / "static" / "webapp.html"
@@ -27,5 +29,6 @@ def get_webapp_html(port=8000):
     # Replace template variables
     html_content = html_template.replace("{{SERVER_PORT}}", str(port))
     html_content = html_content.replace("{{SERVER_MODELS_JS}}", server_models_js)
+    html_content = html_content.replace("{{PLATFORM_JS}}", platform_js)
 
     return HTMLResponse(content=html_content)