lemonade-sdk 7.0.3__py3-none-any.whl → 8.0.0__py3-none-any.whl

lemonade/tools/server/utils/system_tray.py

@@ -0,0 +1,395 @@
+import os
+import sys
+
+# Add pywin32_system32 dlls (missing from embeddable Python executable)
+pywin32_system32 = os.path.join(sys.prefix, "Lib", "site-packages", "pywin32_system32")
+os.add_dll_directory(pywin32_system32)
+
+from win32 import win32gui, win32api
+import win32.lib.win32con as win32con
+import ctypes
+import psutil
+from typing import Dict, Set, Callable, List, Optional, Tuple, Any
+
+# Windows message constants
+WM_USER = 0x0400
+WM_TRAYICON = WM_USER + 1
+WM_COMMAND = 0x0111
+
+
+class MenuItem:
+    def __init__(
+        self,
+        text: str,
+        callback: Optional[Callable] = None,
+        enabled: bool = True,
+        submenu=None,
+        bitmap_path: Optional[str] = None,
+    ):
+        self.text = text
+        self.callback = callback
+        self.enabled = enabled
+        self.submenu = submenu
+        self.bitmap_path = bitmap_path
+        self.id = None  # Will be set when menu is created
+        self.bitmap_handle = None
+
+
+class Menu:
+    SEPARATOR = "SEPARATOR"
+
+    def __init__(self, *items):
+        self.items = list(items)
+
+
+class SystemTray:
+    """
+    Generic system tray implementation for Windows.
+    """
+
+    def __init__(self, app_name: str, icon_path: str):
+        self.app_name = app_name
+        self.icon_path = icon_path
+        self.hwnd = None
+        self.hinst = win32api.GetModuleHandle(None)
+        self.class_atom = None
+        self.notify_id = None
+        self.menu_handle = None
+        self.menu_items = []  # Store menu items with their IDs
+        self.next_menu_id = 1000  # Starting ID for menu items
+
+        # Message map for window procedure
+        self.message_map = {
+            win32con.WM_DESTROY: self.on_destroy,
+            win32con.WM_COMMAND: self.on_command,
+            WM_TRAYICON: self.on_tray_icon,
+        }
+
+    def register_window_class(self):
+        """
+        Register the window class for the tray icon.
+        """
+        window_class = win32gui.WNDCLASS()
+        window_class.hInstance = self.hinst
+        window_class.lpszClassName = f"{self.app_name}TrayClass"
+        window_class.style = win32con.CS_VREDRAW | win32con.CS_HREDRAW
+        window_class.hCursor = win32api.LoadCursor(0, win32con.IDC_ARROW)
+        window_class.hbrBackground = win32con.COLOR_WINDOW
+        window_class.lpfnWndProc = self.window_proc
+
+        self.class_atom = win32gui.RegisterClass(window_class)
+        return self.class_atom
+
+    def create_window(self):
+        """
+        Create a hidden window to receive messages.
+        """
+        style = win32con.WS_OVERLAPPED | win32con.WS_SYSMENU
+        self.hwnd = win32gui.CreateWindow(
+            self.class_atom,
+            f"{self.app_name} Tray",
+            style,
+            0,
+            0,
+            win32con.CW_USEDEFAULT,
+            win32con.CW_USEDEFAULT,
+            0,
+            0,
+            self.hinst,
+            None,
+        )
+
+        # Set the AppUserModelID to identify our app to Windows
+        try:
+            SetCurrentProcessExplicitAppUserModelID = (
+                ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID
+            )
+            SetCurrentProcessExplicitAppUserModelID(ctypes.c_wchar_p(self.app_name))
+        except Exception as e:
+            print(f"Failed to set AppUserModelID: {e}")
+
+        win32gui.UpdateWindow(self.hwnd)
+        return self.hwnd
+
+    def add_tray_icon(self):
+        """
+        Add the tray icon to the system tray.
+        """
+        # Load the .ico file
+        icon_flags = win32con.LR_LOADFROMFILE | win32con.LR_DEFAULTSIZE
+        hicon = win32gui.LoadImage(
+            self.hinst, str(self.icon_path), win32con.IMAGE_ICON, 0, 0, icon_flags
+        )
+
+        flags = win32gui.NIF_ICON | win32gui.NIF_MESSAGE | win32gui.NIF_TIP
+        nid = (self.hwnd, 0, flags, WM_TRAYICON, hicon, self.app_name)
+        win32gui.Shell_NotifyIcon(win32gui.NIM_ADD, nid)
+        self.notify_id = nid
+
+    def show_balloon_notification(self, title, message, timeout=5000):
+        """
+        Show a balloon notification from the tray icon.
+        """
+        if self.notify_id:
+            # The notify_id is a tuple, we need to extract its elements
+            hwnd, id, flags, callback_msg, hicon, tip = self.notify_id
+
+            # Create a new notification with the balloon info
+            flags |= win32gui.NIF_INFO
+
+            # NIIF_USER (0x4) tells Windows to use our custom icon in the notification
+            info_flags = 0x4  # NIIF_USER
+
+            # Create the notification data structure with our custom icon flag
+            nid = (
+                hwnd,
+                id,
+                flags,
+                callback_msg,
+                hicon,
+                self.app_name,
+                message,
+                timeout,
+                title,
+                info_flags,
+            )
+
+            # Show the notification
+            win32gui.Shell_NotifyIcon(win32gui.NIM_MODIFY, nid)
+
+    def window_proc(self, hwnd, message, wparam, lparam):
+        """
+        Window procedure to handle window messages.
+        """
+        if message in self.message_map:
+            return self.message_map[message](hwnd, message, wparam, lparam)
+        return win32gui.DefWindowProc(hwnd, message, wparam, lparam)
+
+    def on_destroy(self, hwnd, message, wparam, lparam):
+        """
+        Handle window destruction.
+        """
+        if self.notify_id:
+            win32gui.Shell_NotifyIcon(win32gui.NIM_DELETE, self.notify_id)
+
+        # Clean up bitmap resources
+        for item_id, item in self.menu_items:
+            if hasattr(item, "bitmap_handle") and item.bitmap_handle:
+                win32gui.DeleteObject(item.bitmap_handle)
+
+        win32gui.PostQuitMessage(0)
+        return 0
+
+    def on_command(self, hwnd, message, wparam, lparam):
+        """
+        Handle menu commands.
+        """
+        menu_id = win32gui.LOWORD(wparam)
+
+        # Find the menu item with this ID and execute its callback
+        for item_id, item_obj in self.menu_items:
+            if item_id == menu_id and item_obj.callback:
+                item_obj.callback(None, item_obj)
+                break
+
+        return 0
+
+    def on_tray_icon(self, hwnd, message, wparam, lparam):
+        """
+        Handle tray icon events.
+        """
+        if lparam == win32con.WM_RBUTTONUP or lparam == win32con.WM_LBUTTONUP:
+            # Show context menu on right-click and left-click
+            self.show_menu()
+        return 0
+
+    def create_menu_item(self, menu_handle, item, pos):
+        """
+        Create a menu item and add it to the menu.
+        """
+        if item == Menu.SEPARATOR:
+            win32gui.AppendMenu(menu_handle, win32con.MF_SEPARATOR, 0, "")
+            return pos + 1
+
+        # Assign a unique ID to this menu item
+        item.id = self.next_menu_id
+        self.next_menu_id += 1
+
+        # Store the menu item with its ID for later lookup
+        self.menu_items.append((item.id, item))
+
+        # Create the menu item
+        flags = win32con.MF_STRING
+
+        if not item.enabled:
+            flags |= win32con.MF_GRAYED
+
+        # Add checkmark if this is a selected item
+        if hasattr(item, "checked") and item.checked:
+            flags |= win32con.MF_CHECKED
+
+        # Handle submenu
+        if item.submenu:
+            submenu_handle = win32gui.CreatePopupMenu()
+            submenu_pos = 0
+            for submenu_item in item.submenu.items:
+                submenu_pos = self.create_menu_item(
+                    submenu_handle, submenu_item, submenu_pos
+                )
+
+            # Add submenu to parent menu
+            win32gui.AppendMenu(
+                menu_handle, win32con.MF_POPUP | flags, submenu_handle, item.text
+            )
+        else:
+            # Add regular menu item first
+            win32gui.AppendMenu(menu_handle, flags, item.id, item.text)
+
+            # Then add bitmap if provided (as a separate step)
+            if item.bitmap_path:
+                try:
+                    # Load the bitmap
+                    icon_flags = win32con.LR_LOADFROMFILE | win32con.LR_DEFAULTSIZE
+                    item.bitmap_handle = win32gui.LoadImage(
+                        self.hinst,
+                        str(item.bitmap_path),
+                        win32con.IMAGE_BITMAP,
+                        0,
+                        0,
+                        icon_flags,
+                    )
+
+                    if item.bitmap_handle:
+                        # Set the bitmap for checked/unchecked states
+                        # Using the same bitmap for both states
+                        win32gui.SetMenuItemBitmaps(
+                            menu_handle,
+                            item.id,
+                            win32con.MF_BYCOMMAND,
+                            item.bitmap_handle,
+                            item.bitmap_handle,
+                        )
+                    else:
+                        print(f"Failed to load bitmap from {item.bitmap_path}")
+                except Exception as e:
+                    print(f"Error adding bitmap to menu item: {e}")
+
+        return pos + 1
+
+    def build_menu(self, menu_items):
+        """
+        Build a menu from a list of menu items.
+        """
+        # Create a new menu
+        menu_handle = win32gui.CreatePopupMenu()
+        pos = 0
+
+        # Clear previous menu items
+        self.menu_items = []
+        self.next_menu_id = 1000
+
+        # Add each item to the menu
+        for item in menu_items:
+            pos = self.create_menu_item(menu_handle, item, pos)
+
+        return menu_handle
+
+    def show_menu(self):
+        """
+        Show the context menu.
+        """
+        # Create menu based on current state
+        menu = self.create_menu()
+        menu_handle = self.build_menu(menu.items)
+
+        # Get cursor position
+        pos = win32gui.GetCursorPos()
+
+        # Make our window the foreground window
+        try:
+            win32gui.SetForegroundWindow(self.hwnd)
+        except Exception:
+            # Ignore errors when setting foreground window
+            # Those are common when the tray icon is already open
+            pass
+
+        # Display the menu
+        win32gui.TrackPopupMenu(
+            menu_handle,
+            win32con.TPM_LEFTALIGN | win32con.TPM_RIGHTBUTTON,
+            pos[0],
+            pos[1],
+            0,
+            self.hwnd,
+            None,
+        )
+
+        # Required by Windows
+        win32gui.PostMessage(self.hwnd, win32con.WM_NULL, 0, 0)
+
+    def create_menu(self):
+        """
+        Create the context menu based on current state. Override in subclass.
+        """
+        return Menu(MenuItem("Exit", self.exit_app))
+
+    def exit_app(self, _, __):
+        """Exit the application."""
+        win32gui.DestroyWindow(self.hwnd)
+
+    def update_menu(self):
+        """
+        Update the menu (will be shown on next right-click).
+        """
+        if self.hwnd:
+            win32gui.InvalidateRect(self.hwnd, None, True)
+
+    def message_loop(self):
+        """
+        Run the Windows message loop.
+        """
+        win32gui.PumpMessages()
+
+    def run(self):
+        """
+        Run the tray application.
+        """
+        # Register window class and create window
+        self.register_window_class()
+        self.create_window()
+
+        # Add tray icon
+        self.add_tray_icon()
+
+        # Run the message loop in the main thread
+        self.message_loop()
+
+    def setup_console_control_handler(self, logger=None):
+        """
+        Set up Windows console control handler for CTRL+C events.
+        This handles graceful shutdown when the console window is closed or CTRL+C is pressed.
+        """
+
+        def console_ctrl_handler(ctrl_type):
+            if ctrl_type in (0, 2):  # CTRL_C_EVENT or CTRL_CLOSE_EVENT
+                if logger:
+                    logger.info(
+                        "Received console control event, shutting down gracefully"
+                    )
+                # Post a quit message to the main thread instead of calling exit_app directly
+                # This avoids thread access issues
+                if self.hwnd:
+                    win32gui.PostMessage(self.hwnd, win32con.WM_CLOSE, 0, 0)
+                return True
+            return False
+
+        # Define the handler function type
+        HANDLER_ROUTINE = ctypes.WINFUNCTYPE(
+            ctypes.wintypes.BOOL, ctypes.wintypes.DWORD
+        )
+        handler = HANDLER_ROUTINE(console_ctrl_handler)
+
+        # Set the console control handler
+        ctypes.windll.kernel32.SetConsoleCtrlHandler(handler, True)
+
+        return handler  # Return handler to keep it in scope

lemonade/tools/server/{instructions.py → webapp.py}

@@ -4,18 +4,12 @@ from fastapi.responses import HTMLResponse
 from lemonade_server.model_manager import ModelManager
 
 
-def get_instructions_html(port=8000):
+def get_webapp_html(port=8000):
     """
-    Show instructions on how to use the server.
+    Show Lemonade Web App for LLM chat and model management.
     """
     # Load server models from JSON
-    server_models_path = (
-        Path(__file__).parent.parent.parent.parent
-        / "lemonade_server"
-        / "server_models.json"
-    )
-    with open(server_models_path, "r", encoding="utf-8") as f:
-        server_models = json.load(f)
+    server_models = ModelManager().supported_models
 
     # Use shared filter function from model_manager.py
     filtered_models = ModelManager().filter_models_by_backend(server_models)
@@ -26,7 +20,7 @@ def get_instructions_html(port=8000):
     )
 
     # Load HTML template
-    template_path = Path(__file__).parent / "static" / "instructions.html"
+    template_path = Path(__file__).parent / "static" / "webapp.html"
     with open(template_path, "r", encoding="utf-8") as f:
         html_template = f.read()
 

lemonade/version.py

@@ -1 +1 @@
-__version__ = "7.0.3"
+__version__ = "8.0.0"

lemonade_install/install.py

@@ -52,7 +52,6 @@ import subprocess
 import sys
 from typing import Optional
 import zipfile
-import requests
 
 DEFAULT_RYZEN_AI_VERSION = "1.4.0"
 version_info_filename = "version_info.json"
@@ -192,6 +191,8 @@ def get_oga_hybrid_dir():
 
 def download_lfs_file(token, file, output_filename):
     """Downloads a file from LFS"""
+    import requests
+
     # Set up the headers for the request
     headers = {
         "Authorization": f"token {token}",
@@ -229,6 +230,8 @@ def download_lfs_file(token, file, output_filename):
 
 
 def download_file(url: str, output_filename: str, description: str = None):
+    import requests
+
     try:
         response = requests.get(url)
         if response.status_code != 200:
@@ -265,55 +268,67 @@ def check_ryzen_ai_processor():
             "Ryzen AI installation is only supported on Windows."
         )
 
+    skip_check = os.getenv("RYZENAI_SKIP_PROCESSOR_CHECK", "").lower() in {
+        "1",
+        "true",
+        "yes",
+    }
+    if skip_check:
+        print("[WARNING]: Processor check skipped.")
+        return
+
     is_supported = False
     cpu_name = ""
 
     try:
-        # Use Windows registry to get CPU information
+        # Use PowerShell command to get processor name
+        powershell_cmd = [
+            "powershell",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-Command",
+            "Get-WmiObject -Class Win32_Processor | Select-Object -ExpandProperty Name",
+        ]
+
         result = subprocess.run(
-            [
-                "reg",
-                "query",
-                "HKEY_LOCAL_MACHINE\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
-                "/v",
-                "ProcessorNameString",
-            ],
+            powershell_cmd,
             capture_output=True,
             text=True,
             check=True,
         )
 
-        # Parse the output to extract the CPU name
-        for line in result.stdout.splitlines():
-            if "ProcessorNameString" in line:
-                # The format is typically: name REG_SZ value
-                parts = line.strip().split("REG_SZ")
-                if len(parts) >= 2:
-                    cpu_name = parts[1].strip()
-                break
+        # Extract the CPU name from PowerShell output
+        cpu_name = result.stdout.strip()
+        if not cpu_name:
+            print(
+                "[WARNING]: Could not detect processor name. Proceeding with installation."
+            )
+            return
 
         # Check for any supported series
         for series in SUPPORTED_RYZEN_AI_SERIES:
             # Look for the series number pattern - matches any processor in the supported series
             pattern = rf"ryzen ai.*\b{series[0]}\d{{2}}\b"
             match = re.search(pattern, cpu_name.lower(), re.IGNORECASE)
+
             if match:
                 is_supported = True
                 break
 
-    except Exception:  # pylint: disable=broad-exception-caught
-        supported_series_str = ", ".join(SUPPORTED_RYZEN_AI_SERIES)
-        raise UnsupportedPlatformError(
-            f"Ryzen AI installation requires a Ryzen AI {supported_series_str} "
-            f"series processor. Processor detection failed."
-        )
+        if not is_supported:
+            print(
+                f"[WARNING]: Processor '{cpu_name}' may not be officially supported for Ryzen AI hybrid execution."
+            )
+            print(
+                "[WARNING]: Installation will proceed, but hybrid features may not work correctly."
+            )
+            print("[WARNING]: Officially supported processors: Ryzen AI 300-series")
 
-    if not is_supported:
-        supported_series_str = ", ".join(SUPPORTED_RYZEN_AI_SERIES)
-        raise UnsupportedPlatformError(
-            f"Ryzen AI installation requires a Ryzen AI {supported_series_str} "
-            f"series processor. Your current processor ({cpu_name}) is not supported."
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        print(
+            f"[WARNING]: Could not detect processor ({e}). Proceeding with installation."
         )
+        print("[WARNING]: Hybrid features may not work if processor is not supported.")
 
 
 def download_and_extract_package(
@@ -334,6 +349,8 @@ def download_and_extract_package(
     Returns:
         str: Path where package was extracted (renamed to package-version)
     """
+    import requests
+
     zip_filename = f"{package_name}-{version}.zip"
     zip_path = os.path.join(install_dir, zip_filename)
     target_folder = os.path.join(install_dir, f"{package_name}-{version}")
@@ -691,6 +708,7 @@ class Install:
             raise ValueError(
                 f"Value passed to ryzenai argument is not supported: {ryzenai}"
             )
+
         if build_model:
             model_prep_file = Install._install_ryzenai_model_artifacts(
                 ryzen_ai_folder, version