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

lemonade/common/inference_engines.py

@@ -24,7 +24,7 @@ class InferenceEngineDetector:
         Detect all available inference engines for a specific device type.
 
         Args:
-            device_type: "cpu", "amd_igpu", "amd_dgpu", or "npu"
+            device_type: "cpu", "amd_igpu", "amd_dgpu", "nvidia_dgpu", or "npu"
 
         Returns:
             dict: Engine availability information
@@ -223,17 +223,26 @@ class LlamaCppDetector(BaseEngineDetector):
         """
         try:
 
-            if device_type not in ["cpu", "amd_igpu", "amd_dgpu"]:
+            if device_type not in ["cpu", "amd_igpu", "amd_dgpu", "nvidia_dgpu"]:
                 return None
 
             # Check if the device is supported by the backend
             if device_type == "cpu":
                 device_supported = True
-            elif device_type == "amd_igpu" or device_type == "amd_dgpu":
+            elif device_type in ["amd_igpu", "amd_dgpu"]:
                 if backend == "vulkan":
                     device_supported = self._check_vulkan_support()
                 elif backend == "rocm":
                     device_supported = self._check_rocm_support(device_name.lower())
+                else:
+                    device_supported = False
+            elif device_type == "nvidia_dgpu":
+                if backend == "vulkan":
+                    device_supported = self._check_vulkan_support()
+                else:
+                    device_supported = False
+            else:
+                device_supported = False
             if not device_supported:
                 return {"available": False, "error": f"{backend} not available"}
 
@@ -390,7 +399,7 @@ def detect_inference_engines(device_type: str, device_name: str) -> Dict[str, Di
     Helper function to detect inference engines for a device type.
 
     Args:
-        device_type: "cpu", "amd_igpu", "amd_dgpu", or "npu"
+        device_type: "cpu", "amd_igpu", "amd_dgpu", "nvidia_dgpu", or "npu"
         device_name: device name
 
     Returns:

lemonade/common/system_info.py

@@ -1,9 +1,11 @@
 from abc import ABC, abstractmethod
 import importlib.metadata
+import logging
 import platform
 import re
 import subprocess
 import ctypes
+import glob
 from .inference_engines import detect_inference_engines
 
 # AMD GPU classification keywords - shared across all OS implementations
@@ -19,6 +21,28 @@ AMD_DISCRETE_GPU_KEYWORDS = [
     "fury",
 ]
 
+# NVIDIA GPU classification keywords - shared across all OS implementations
+# NVIDIA GPUs are typically discrete by default, but we include keywords for clarity
+NVIDIA_DISCRETE_GPU_KEYWORDS = [
+    "geforce",
+    "rtx",
+    "gtx",
+    "quadro",
+    "tesla",
+    "titan",
+    "a100",
+    "a40",
+    "a30",
+    "a10",
+    "a6000",
+    "a5000",
+    "a4000",
+    "a2000",
+    "t1000",
+    "t600",
+    "t400",
+]
+
 
 class SystemInfo(ABC):
     """
@@ -51,6 +75,7 @@ class SystemInfo(ABC):
             "cpu": self.get_cpu_device(),
             "amd_igpu": self.get_amd_igpu_device(include_inference_engines=True),
             "amd_dgpu": self.get_amd_dgpu_devices(include_inference_engines=True),
+            "nvidia_dgpu": self.get_nvidia_dgpu_devices(include_inference_engines=True),
             "npu": self.get_npu_device(),
         }
         return device_dict
@@ -82,6 +107,15 @@ class SystemInfo(ABC):
             list: List of AMD dGPU device information.
         """
 
+    @abstractmethod
+    def get_nvidia_dgpu_devices(self, include_inference_engines: bool = False) -> list:
+        """
+        Retrieves NVIDIA discrete GPU device information.
+
+        Returns:
+            list: List of NVIDIA dGPU device information.
+        """
+
     @abstractmethod
     def get_npu_device(self) -> dict:
         """
@@ -173,34 +207,56 @@ class WindowsSystemInfo(SystemInfo):
         Returns:
             list: List of detected GPU info dictionaries
         """
+        logging.debug(f"Starting AMD GPU detection for type: {gpu_type}")
         gpu_devices = []
         try:
             video_controllers = self.connection.Win32_VideoController()
-            for controller in video_controllers:
+            logging.debug(f"Found {len(video_controllers)} video controllers")
+
+            for i, controller in enumerate(video_controllers):
+                logging.debug(
+                    f"Controller {i}: Name='{controller.Name}', "
+                    f"PNPDeviceID='{getattr(controller, 'PNPDeviceID', 'N/A')}'"
+                )
+
                 if (
                     controller.Name
                     and "AMD" in controller.Name
                     and "Radeon" in controller.Name
                 ):
+                    logging.debug(f"Found AMD Radeon GPU: {controller.Name}")
 
                     name_lower = controller.Name.lower()
+                    logging.debug(f"GPU name (lowercase): {name_lower}")
 
                     # Keyword-based classification - simple and reliable
+                    matching_keywords = [
+                        kw for kw in AMD_DISCRETE_GPU_KEYWORDS if kw in name_lower
+                    ]
                     is_discrete_by_name = any(
                         kw in name_lower for kw in AMD_DISCRETE_GPU_KEYWORDS
                     )
                     is_integrated = not is_discrete_by_name
 
+                    logging.debug(f"Matching discrete keywords: {matching_keywords}")
+                    logging.debug(
+                        f"Classified as discrete: {not is_integrated}, integrated: {is_integrated}"
+                    )
+
                     # Filter based on requested type
                     if (gpu_type == "integrated" and is_integrated) or (
                         gpu_type == "discrete" and not is_integrated
                     ):
+                        logging.debug(
+                            f"GPU matches requested type '{gpu_type}', processing..."
+                        )
 
                         device_type = "amd_igpu" if is_integrated else "amd_dgpu"
                         gpu_info = {
                             "name": controller.Name,
                             "available": True,
                         }
+                        logging.debug(f"Created GPU info for {device_type}: {gpu_info}")
 
                         driver_version = self.get_driver_version(
                             "AMD-OpenCL User Mode Driver"
@@ -208,6 +264,21 @@ class WindowsSystemInfo(SystemInfo):
                         gpu_info["driver_version"] = (
                             driver_version if driver_version else "Unknown"
                         )
+                        logging.debug(f"Driver version: {gpu_info['driver_version']}")
+
+                        # Get VRAM information for discrete GPUs
+                        if not is_integrated:  # Only add VRAM for discrete GPUs
+                            # Try dxdiag first (most reliable for dedicated memory)
+                            vram_gb = self._get_gpu_vram_dxdiag_simple(controller.Name)
+
+                            # Fallback to WMI if dxdiag fails
+                            if vram_gb == 0.0:
+                                vram_gb = self._get_gpu_vram_wmi(controller)
+
+                            if vram_gb > 0.0:
+                                gpu_info["vram_gb"] = vram_gb
+                            else:
+                                gpu_info["vram_gb"] = "Unknown"
 
                         if include_inference_engines:
                             gpu_info["inference_engines"] = (
@@ -216,11 +287,26 @@ class WindowsSystemInfo(SystemInfo):
                                 )
                             )
                         gpu_devices.append(gpu_info)
+                        logging.debug(f"Added GPU to devices list: {gpu_info}")
+                    else:
+                        logging.debug(
+                            f"GPU does not match requested type '{gpu_type}', skipping"
+                        )
+                        continue
+                else:
+                    logging.debug(
+                        f"Skipping non-AMD/non-Radeon controller: {controller.Name}"
+                    )
 
         except Exception as e:  # pylint: disable=broad-except
             error_msg = f"AMD {gpu_type} GPU detection failed: {e}"
+            logging.debug(f"Exception in AMD GPU detection: {e}")
             return [{"available": False, "error": error_msg}]
 
+        logging.debug(
+            f"AMD GPU detection completed. Found {len(gpu_devices)} {gpu_type} GPUs: "
+            f"{[gpu.get('name', 'Unknown') for gpu in gpu_devices]}"
+        )
         return gpu_devices
 
     def get_amd_igpu_device(self, include_inference_engines: bool = False) -> dict:
@@ -255,6 +341,67 @@ class WindowsSystemInfo(SystemInfo):
             else [{"available": False, "error": "No AMD discrete GPU found"}]
         )
 
+    def get_nvidia_dgpu_devices(self, include_inference_engines: bool = False) -> list:
+        """
+        Retrieves NVIDIA discrete GPU device information using WMI.
+
+        Returns:
+            list: List of NVIDIA dGPU device information.
+        """
+        gpu_devices = []
+        try:
+            video_controllers = self.connection.Win32_VideoController()
+            for controller in video_controllers:
+                if controller.Name and "NVIDIA" in controller.Name.upper():
+                    name_lower = controller.Name.lower()
+
+                    # Most NVIDIA GPUs are discrete, but we can check keywords for confirmation
+                    is_discrete = (
+                        any(kw in name_lower for kw in NVIDIA_DISCRETE_GPU_KEYWORDS)
+                        or "nvidia" in name_lower
+                    )  # Default to discrete for NVIDIA
+
+                    if is_discrete:
+                        gpu_info = {
+                            "name": controller.Name,
+                            "available": True,
+                        }
+
+                        # Try to get NVIDIA driver version using multiple methods
+                        driver_version = self._get_nvidia_driver_version_windows()
+                        gpu_info["driver_version"] = (
+                            driver_version if driver_version else "Unknown"
+                        )
+
+                        # Get VRAM information
+                        vram_gb = self._get_gpu_vram_wmi(controller)
+                        if vram_gb == 0.0:
+                            # Fallback to nvidia-smi
+                            vram_gb = self._get_nvidia_vram_smi()
+
+                        if vram_gb > 0.0:
+                            gpu_info["vram_gb"] = vram_gb
+                        else:
+                            gpu_info["vram_gb"] = "Unknown"
+
+                        if include_inference_engines:
+                            gpu_info["inference_engines"] = (
+                                self._detect_inference_engines(
+                                    "nvidia_dgpu", controller.Name
+                                )
+                            )
+                        gpu_devices.append(gpu_info)
+
+        except Exception as e:  # pylint: disable=broad-except
+            error_msg = f"NVIDIA discrete GPU detection failed: {e}"
+            return [{"available": False, "error": error_msg}]
+
+        return (
+            gpu_devices
+            if gpu_devices
+            else [{"available": False, "error": "No NVIDIA discrete GPU found"}]
+        )
+
     def get_npu_device(self) -> dict:
         """
         Retrieves NPU device information using existing methods.
@@ -374,6 +521,169 @@ class WindowsSystemInfo(SystemInfo):
             return drivers[0].DriverVersion
         return ""
 
+    def _get_gpu_vram_wmi(self, controller) -> float:
+        """
+        Get GPU VRAM from WMI VideoController.
+
+        Args:
+            controller: WMI Win32_VideoController object
+
+        Returns:
+            float: VRAM in GB, or 0.0 if detection fails
+        """
+        try:
+            if hasattr(controller, "AdapterRAM"):
+                adapter_ram = controller.AdapterRAM
+                if adapter_ram and adapter_ram > 0:
+                    # AdapterRAM is in bytes, convert to GB
+                    vram_bytes = int(adapter_ram)
+                    vram_gb = round(vram_bytes / (1024**3), 1)
+                    return vram_gb
+        except (ValueError, AttributeError):
+            pass
+        return 0.0
+
+    def _get_gpu_vram_dxdiag_simple(self, gpu_name: str) -> float:
+        """
+        Get GPU VRAM using dxdiag, looking specifically for dedicated memory.
+
+        Args:
+            gpu_name: Name of the GPU to look for
+
+        Returns:
+            float: VRAM in GB, or 0.0 if detection fails
+        """
+        try:
+            import tempfile
+            import os
+
+            with tempfile.NamedTemporaryFile(
+                mode="w+", suffix=".txt", delete=False
+            ) as temp_file:
+                temp_path = temp_file.name
+
+            try:
+                subprocess.run(
+                    ["dxdiag", "/t", temp_path],
+                    check=True,
+                    timeout=30,
+                    capture_output=True,
+                )
+
+                with open(temp_path, "r", encoding="utf-8", errors="ignore") as f:
+                    dxdiag_output = f.read()
+
+                lines = dxdiag_output.split("\n")
+                found_gpu = False
+
+                for line in lines:
+                    line = line.strip()
+
+                    # Check if this is our GPU
+                    if "Card name:" in line and gpu_name.lower() in line.lower():
+                        found_gpu = True
+                        continue
+
+                    # Look for dedicated memory line
+                    if found_gpu and "Dedicated Memory:" in line:
+                        memory_match = re.search(
+                            r"(\d+(?:\.\d+)?)\s*MB", line, re.IGNORECASE
+                        )
+                        if memory_match:
+                            vram_mb = float(memory_match.group(1))
+                            vram_gb = round(vram_mb / 1024, 1)
+                            return vram_gb
+
+                    # Reset if we hit another display device
+                    if "Card name:" in line and gpu_name.lower() not in line.lower():
+                        found_gpu = False
+
+            finally:
+                try:
+                    os.unlink(temp_path)
+                except Exception:  # pylint: disable=broad-except
+                    pass
+
+        except Exception:  # pylint: disable=broad-except
+            pass
+
+        return 0.0
+
+    def _get_nvidia_driver_version_windows(self) -> str:
+        """
+        Get NVIDIA driver version on Windows using nvidia-smi and WMI fallback.
+
+        Returns:
+            str: Driver version, or empty string if detection fails
+        """
+        # Primary: Try nvidia-smi command
+        try:
+            output = (
+                subprocess.check_output(
+                    [
+                        "nvidia-smi",
+                        "--query-gpu=driver_version",
+                        "--format=csv,noheader,nounits",
+                    ],
+                    stderr=subprocess.DEVNULL,
+                )
+                .decode()
+                .strip()
+            )
+            if output and output != "N/A":
+                return output.split("\n")[0]
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            pass
+
+        # Fallback: Try WMI Win32_PnPSignedDriver with NVIDIA patterns
+        try:
+            nvidia_patterns = [
+                "NVIDIA GeForce",
+                "NVIDIA RTX",
+                "NVIDIA GTX",
+                "NVIDIA Quadro",
+            ]
+            all_drivers = self.connection.Win32_PnPSignedDriver()
+            for driver in all_drivers:
+                if driver.DeviceName and any(
+                    pattern in driver.DeviceName for pattern in nvidia_patterns
+                ):
+                    if driver.DriverVersion:
+                        return driver.DriverVersion
+        except Exception:  # pylint: disable=broad-except
+            pass
+
+        return ""
+
+    def _get_nvidia_vram_smi(self) -> float:
+        """
+        Get NVIDIA GPU VRAM using nvidia-smi command.
+
+        Returns:
+            float: VRAM in GB, or 0.0 if detection fails
+        """
+        try:
+            output = (
+                subprocess.check_output(
+                    [
+                        "nvidia-smi",
+                        "--query-gpu=memory.total",
+                        "--format=csv,noheader,nounits",
+                    ],
+                    stderr=subprocess.DEVNULL,
+                )
+                .decode()
+                .strip()
+            )
+
+            # nvidia-smi returns memory in MB
+            vram_mb = int(output.split("\n")[0])
+            vram_gb = round(vram_mb / 1024, 1)
+            return vram_gb
+        except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
+            pass
+        return 0.0
+
     @staticmethod
     def get_npu_power_mode() -> str:
         """
@@ -490,6 +800,14 @@ class WSLSystemInfo(SystemInfo):
         """
         return []
 
+    def get_nvidia_dgpu_devices(self, include_inference_engines: bool = False) -> list:
+        """
+        Retrieves NVIDIA discrete GPU device information in WSL environment.
+        """
+        return [
+            {"available": False, "error": "NVIDIA GPU detection not supported in WSL"}
+        ]
+
     def get_npu_device(self) -> dict:
         """
         Retrieves NPU device information in WSL environment.
@@ -625,6 +943,20 @@ class LinuxSystemInfo(SystemInfo):
                             "name": device_name,
                             "available": True,
                         }
+
+                        # Get VRAM information for discrete GPUs
+                        if not is_integrated:  # Only add VRAM for discrete GPUs
+                            vram_gb = self._get_amd_vram_rocm_smi_linux()
+                            if vram_gb == 0.0:
+                                # Fallback to sysfs - extract PCI ID from lspci line
+                                pci_id = line.split()[0] if line else ""
+                                vram_gb = self._get_amd_vram_sysfs(pci_id)
+
+                            if vram_gb > 0.0:
+                                gpu_info["vram_gb"] = vram_gb
+                            else:
+                                gpu_info["vram_gb"] = "Unknown"
+
                         if include_inference_engines:
                             gpu_info["inference_engines"] = (
                                 self._detect_inference_engines(device_type, device_name)
@@ -669,6 +1001,66 @@ class LinuxSystemInfo(SystemInfo):
             else [{"available": False, "error": "No AMD discrete GPU found"}]
         )
 
+    def get_nvidia_dgpu_devices(self, include_inference_engines: bool = False) -> list:
+        """
+        Retrieves NVIDIA discrete GPU device information using lspci.
+
+        Returns:
+            list: List of NVIDIA dGPU device information.
+        """
+        gpu_devices = []
+        try:
+            lspci_output = subprocess.check_output(
+                "lspci | grep -i 'vga\\|3d\\|display'", shell=True
+            ).decode()
+
+            for line in lspci_output.split("\n"):
+                if line.strip() and "NVIDIA" in line.upper():
+                    name_lower = line.lower()
+
+                    # Most NVIDIA GPUs are discrete, check keywords for confirmation
+                    is_discrete = (
+                        any(kw in name_lower for kw in NVIDIA_DISCRETE_GPU_KEYWORDS)
+                        or "nvidia" in name_lower
+                    )  # Default to discrete for NVIDIA
+
+                    if is_discrete:
+                        device_name = line.split(": ")[1] if ": " in line else line
+
+                        gpu_info = {
+                            "name": device_name,
+                            "available": True,
+                        }
+
+                        # Try to get NVIDIA driver version using multiple methods
+                        driver_version = self._get_nvidia_driver_version_linux()
+                        gpu_info["driver_version"] = (
+                            driver_version if driver_version else "Unknown"
+                        )
+
+                        # Get VRAM information
+                        vram_gb = self._get_nvidia_vram_smi_linux()
+                        if vram_gb > 0.0:
+                            gpu_info["vram_gb"] = vram_gb
+
+                        if include_inference_engines:
+                            gpu_info["inference_engines"] = (
+                                self._detect_inference_engines(
+                                    "nvidia_dgpu", device_name
+                                )
+                            )
+                        gpu_devices.append(gpu_info)
+
+        except Exception as e:  # pylint: disable=broad-except
+            error_msg = f"NVIDIA discrete GPU detection failed: {e}"
+            return [{"available": False, "error": error_msg}]
+
+        return (
+            gpu_devices
+            if gpu_devices
+            else [{"available": False, "error": "No NVIDIA discrete GPU found"}]
+        )
+
     def get_npu_device(self) -> dict:
         """
         Retrieves NPU device information (limited support on Linux).
@@ -681,6 +1073,69 @@ class LinuxSystemInfo(SystemInfo):
             "error": "NPU detection not yet implemented for Linux",
         }
 
+    def _get_nvidia_driver_version_linux(self) -> str:
+        """
+        Get NVIDIA driver version on Linux using nvidia-smi and proc fallback.
+
+        Returns:
+            str: Driver version, or empty string if detection fails
+        """
+        # Primary: Try nvidia-smi command
+        try:
+            output = (
+                subprocess.check_output(
+                    "nvidia-smi --query-gpu=driver_version --format=csv,noheader,nounits",
+                    shell=True,
+                    stderr=subprocess.DEVNULL,
+                )
+                .decode()
+                .strip()
+            )
+            if output and output != "N/A":
+                return output.split("\n")[0]
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            pass
+
+        # Fallback: Try /proc/driver/nvidia/version
+        try:
+            with open("/proc/driver/nvidia/version", "r", encoding="utf-8") as f:
+                content = f.read()
+                # Look for version pattern like "NVRM version:
+                #   NVIDIA UNIX x86_64 Kernel Module  470.82.00"
+                match = re.search(r"Kernel Module\s+(\d+\.\d+(?:\.\d+)?)", content)
+                if match:
+                    return match.group(1)
+        except (FileNotFoundError, IOError):
+            pass
+
+        return ""
+
+    def _get_nvidia_vram_smi_linux(self) -> float:
+        """
+        Get NVIDIA GPU VRAM on Linux using nvidia-smi command.
+
+        Returns:
+            float: VRAM in GB, or 0.0 if detection fails
+        """
+        try:
+            output = (
+                subprocess.check_output(
+                    "nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits",
+                    shell=True,
+                    stderr=subprocess.DEVNULL,
+                )
+                .decode()
+                .strip()
+            )
+
+            # nvidia-smi returns memory in MB
+            vram_mb = int(output.split("\n")[0])
+            vram_gb = round(vram_mb / 1024, 1)
+            return vram_gb
+        except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
+            pass
+        return 0.0
+
     @staticmethod
     def get_processor_name() -> str:
         """
@@ -758,6 +1213,109 @@ class LinuxSystemInfo(SystemInfo):
         info_dict["Physical Memory"] = self.get_physical_memory()
         return info_dict
 
+    def _get_nvidia_vram_smi_linux(self) -> float:
+        """
+        Get NVIDIA GPU VRAM using nvidia-smi command on Linux.
+
+        Returns:
+            float: VRAM in GB, or 0.0 if detection fails
+        """
+        try:
+            output = (
+                subprocess.check_output(
+                    [
+                        "nvidia-smi",
+                        "--query-gpu=memory.total",
+                        "--format=csv,noheader,nounits",
+                    ],
+                    stderr=subprocess.DEVNULL,
+                )
+                .decode()
+                .strip()
+            )
+
+            # nvidia-smi returns memory in MB
+            vram_mb = int(output.split("\n")[0])
+            vram_gb = round(vram_mb / 1024, 1)
+            return vram_gb
+        except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
+            pass
+        return 0.0
+
+    def _get_amd_vram_rocm_smi_linux(self) -> float:
+        """
+        Get AMD GPU VRAM using rocm-smi command on Linux.
+
+        Returns:
+            float: VRAM in GB, or 0.0 if detection fails
+        """
+        try:
+            output = (
+                subprocess.check_output(
+                    ["rocm-smi", "--showmeminfo", "vram", "--csv"],
+                    stderr=subprocess.DEVNULL,
+                )
+                .decode()
+                .strip()
+            )
+
+            # Parse CSV output to extract VRAM
+            lines = output.split("\n")
+            for line in lines:
+                if "Total VRAM" in line or "vram" in line.lower():
+                    # Extract numeric value (assuming it's in MB or GB)
+                    numbers = re.findall(r"\d+", line)
+                    if numbers:
+                        vram_value = int(numbers[0])
+                        # Assume MB if value is large, GB if small
+                        if vram_value > 100:  # Likely MB
+                            vram_gb = round(vram_value / 1024, 1)
+                        else:  # Likely GB
+                            vram_gb = float(vram_value)
+                        return vram_gb
+        except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
+            pass
+        return 0.0
+
+    def _get_amd_vram_sysfs(self, pci_id: str) -> float:
+        """
+        Get AMD GPU VRAM using sysfs on Linux.
+
+        Args:
+            pci_id: PCI ID of the GPU (e.g., "0000:01:00.0")
+
+        Returns:
+            float: VRAM in GB, or 0.0 if detection fails
+        """
+        try:
+            # Try different sysfs paths for VRAM information
+            sysfs_paths = [
+                f"/sys/bus/pci/devices/{pci_id}/mem_info_vram_total",
+                "/sys/class/drm/card*/device/mem_info_vram_total",
+            ]
+
+            for path in sysfs_paths:
+                try:
+                    if "*" in path:
+                        # Handle wildcard paths
+                        matching_paths = glob.glob(path)
+                        for match_path in matching_paths:
+                            with open(match_path, "r", encoding="utf-8") as f:
+                                vram_bytes = int(f.read().strip())
+                                vram_gb = round(vram_bytes / (1024**3), 1)
+                                if vram_gb > 0:
+                                    return vram_gb
+                    else:
+                        with open(path, "r", encoding="utf-8") as f:
+                            vram_bytes = int(f.read().strip())
+                            vram_gb = round(vram_bytes / (1024**3), 1)
+                            return vram_gb
+                except (FileNotFoundError, ValueError, PermissionError):
+                    continue
+        except Exception:  # pylint: disable=broad-except
+            pass
+        return 0.0
+
     def _detect_inference_engines(self, device_type: str, device_name: str) -> dict:
         """
         Detect available inference engines for a specific device type.
@@ -803,6 +1361,17 @@ class UnsupportedOSSystemInfo(SystemInfo):
         """
         return []
 
+    def get_nvidia_dgpu_devices(self, include_inference_engines: bool = False) -> list:
+        """
+        Retrieves NVIDIA discrete GPU device information for unsupported OS.
+        """
+        return [
+            {
+                "available": False,
+                "error": "Device detection not supported on this operating system",
+            }
+        ]
+
     def get_npu_device(self) -> dict:
         """
         Retrieves NPU device information for unsupported OS.

lemonade/tools/llamacpp/utils.py

@@ -510,14 +510,14 @@ def identify_gguf_models(
     The CHECKPOINT:VARIANT scheme is used to specify model files in Hugging Face repositories.
 
     The VARIANT format can be one of several types:
-    0. wildcard (*): download all files in the repo
+    0. wildcard (*): download all .gguf files in the repo
     1. Full filename: exact file to download
     2. None/empty: gets the first .gguf file in the repository (excludes mmproj files)
     3. Quantization variant: find a single file ending with the variant name (case insensitive)
     4. Folder name: downloads all .gguf files in the folder that matches the variant name (case insensitive)
 
     Examples:
-    - "ggml-org/gpt-oss-120b-GGUF:*" -> downloads all files in repo
+    - "ggml-org/gpt-oss-120b-GGUF:*" -> downloads all .gguf files in repo
     - "unsloth/Qwen3-8B-GGUF:qwen3.gguf" -> downloads "qwen3.gguf"
     - "unsloth/Qwen3-30B-A3B-GGUF" -> downloads "Qwen3-30B-A3B-GGUF.gguf"
     - "unsloth/Qwen3-8B-GGUF:Q4_1" -> downloads "Qwen3-8B-GGUF-Q4_1.gguf"
@@ -531,13 +531,14 @@ def identify_gguf_models(
 
     # (case 0) Wildcard, download everything
     if variant and variant == "*":
-        sharded_files = repo_files
+        sharded_files = [f for f in repo_files if f.endswith(".gguf")]
 
         # Sort to ensure consistent ordering
         sharded_files.sort()
 
         # Use first file as primary (this is how llamacpp handles it)
         variant_name = sharded_files[0]
+
     # (case 1) If variant ends in .gguf, use it directly
     elif variant and variant.endswith(".gguf"):
         variant_name = variant

lemonade/tools/server/serve.py

@@ -164,6 +164,7 @@ class Server:
     - /api/v1/chat/completions: chat completion responses using HTTP chunked transfer encoding.
     - /api/v1/responses: responses API using HTTP chunked transfer encoding.
     - /api/v1/models: list all available models.
+    - /api/v1/models/{model_id}: retrieve a specific model by ID.
     """
 
     def __init__(
@@ -269,6 +270,7 @@ class Server:
             self.app.post(f"{prefix}/chat/completions")(self.chat_completions)
             self.app.post(f"{prefix}/embeddings")(self.embeddings)
             self.app.get(f"{prefix}/models")(self.models)
+            self.app.get(f"{prefix}/models/{{model_id}}")(self.retrieve_model)
 
             # JinaAI routes (jina.ai/reranker/)
             self.app.post(f"{prefix}/reranking")(self.reranking)
@@ -1590,6 +1592,36 @@ class Server:
 
         return {"object": "list", "data": models_list}
 
+    async def retrieve_model(self, model_id: str):
+        """
+        Retrieve a specific model by ID in OpenAI-compatible format.
+        """
+        # Raise an error if the model does not exist
+        if model_id not in self.local_models:
+            # Mimic the error format of the OpenAI API
+            raise HTTPException(
+                status_code=404,
+                detail={
+                    "message": f"model {model_id} not found",
+                    "type": "api_error",
+                    "param": None,
+                    "code": None,
+                },
+            )
+
+        # Return the specific model
+        model_info = self.local_models[model_id]
+        model = ServerModel(
+            id=model_id,
+            owned_by="lemonade",
+            object="model",
+            created=int(time.time()),
+            checkpoint=model_info["checkpoint"],
+            recipe=model_info["recipe"],
+        )
+
+        return model
+
     def setup_middleware_timer(self):
         logging.info("Middleware set up")
 

lemonade/tools/server/tray.py

@@ -7,9 +7,12 @@ import webbrowser
 from pathlib import Path
 import logging
 import tempfile
+
 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
 
@@ -57,6 +60,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"
 
@@ -282,6 +286,41 @@ class LemonadeTray(SystemTray):
             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 +477,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 +515,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

lemonade/version.py

@@ -1 +1 @@
-__version__ = "8.1.9"
+__version__ = "8.1.10"

{lemonade_sdk-8.1.9.dist-info → lemonade_sdk-8.1.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lemonade-sdk
-Version: 8.1.9
+Version: 8.1.10
 Summary: Lemonade SDK: Your LLM Aide for Validation and Deployment
 Author-email: lemonade@amd.com
 Requires-Python: >=3.10, <3.14

{lemonade_sdk-8.1.9.dist-info → lemonade_sdk-8.1.10.dist-info}/RECORD

@@ -4,17 +4,17 @@ lemonade/cache.py,sha256=5iZbk273TiTMqK_vdzPOPYTo6VsWW2gNByOISA9zi1w,3002
 lemonade/cli.py,sha256=qU5bW7RQAUKNSpvrhVyzn68NMxyi-336Ke_JU4bsv1Q,5708
 lemonade/sequence.py,sha256=KSH7BPsiyDKsOsg_ziQKEGsDwMmuO_YbgPRBxkZd0pw,13267
 lemonade/state.py,sha256=sdSezla7Cd7KYL90xY3p9kcNV4ndSyN6UvNLOr3vBMA,5261
-lemonade/version.py,sha256=nNxNovCuweKgLzK71oDtPCagHKqrBZW7fNRdrO5VFWA,22
+lemonade/version.py,sha256=BSj3P5N0EwzL0-jahgtLzMLFGfZHooaYa76BeUiW2wc,23
 lemonade/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lemonade/common/build.py,sha256=zTb0m1-kuUx6zw5QHp2SNnVuN6jOTMQ2FCdj9iH374U,6140
 lemonade/common/cli_helpers.py,sha256=hjBfXrTtFl8gmCFlL-ksviXR0mOcdPtTWVNKoEp3PG4,4993
 lemonade/common/exceptions.py,sha256=w83sVKmL1QXoJlGjj_bRyjIBMhlMqdVQy_FEOTu2YQI,2050
 lemonade/common/filesystem.py,sha256=QV3cHhKNu-7W2rr8wZ4JQfD2rP_5T2Js7jiDQBYWHVQ,12142
-lemonade/common/inference_engines.py,sha256=pJxn0zOf3gEmjGAIWXNdCibfzarzc7LRbZjoQyygkcU,12591
+lemonade/common/inference_engines.py,sha256=3bUGQe9wtfTiwt8kvI_ry077uyc9lid2G1fJX95kN1A,12969
 lemonade/common/network.py,sha256=qXpUjDYQEYM_gH3JwTtU-pu_yCKcaa1IeohJRPy91-A,2903
 lemonade/common/printing.py,sha256=GFFzrXIineIOMa9yu0lo5sL4j6A5BBg_T9aUCdP-juw,3229
 lemonade/common/status.py,sha256=xSOZN508cdRtrs1HVyr9zmASYg69EsZBLSs0lroLoCM,16519
-lemonade/common/system_info.py,sha256=pn-k3zMQCbt5cu3aHXa4cENgrubOK97gs9PYdGPsFXA,28405
+lemonade/common/system_info.py,sha256=Msa0pCSj3ZN3nerjY8wdqjjJLg6GPhbWf2htSNcFIHc,49607
 lemonade/common/test_helpers.py,sha256=Gwk-pa_6xYAo2oro-2EJNfuouAfw8k_brCbcMC-E-r0,758
 lemonade/profilers/__init__.py,sha256=JKVonvJ4XZ9_6sKXPWsiMLQCNyzQOxhQw5BEHR1qOfU,31
 lemonade/profilers/agt_power.py,sha256=t_37VEg8LPapjSKSjJln-jFznZtTIf5UpzlAXcVGOrc,16771
@@ -36,7 +36,7 @@ lemonade/tools/huggingface/load.py,sha256=KsSGOBBD-tNEIfYC8mCWV_jpnkjHMhN3juVmC1
 lemonade/tools/huggingface/utils.py,sha256=j1S-IgjDsznUIVwkHSqqChmFyqIx9f3WcEelzohWwvU,13955
 lemonade/tools/llamacpp/bench.py,sha256=1fkE02ecg-jRk92i5dTAXz6re14WH8bd-Z9l-m3lbDA,4844
 lemonade/tools/llamacpp/load.py,sha256=DFCvQN548Ch9H8U_rHOiYviinzw6vixb5-V7xLj7XE4,6499
-lemonade/tools/llamacpp/utils.py,sha256=nl11DRJCzcDV7OcAJtA0YRVxStdBvcnLZbhDhUrN1So,33041
+lemonade/tools/llamacpp/utils.py,sha256=WEjdGmVxl30rt0a62MNo_X8ndFQ2SIrqtA2uF3klE6g,33090
 lemonade/tools/oga/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lemonade/tools/oga/bench.py,sha256=PJXv4UchcS2YPwijNzef8DY4DSAKYxIYY1ycHuH3T34,5005
 lemonade/tools/oga/load.py,sha256=x-A-nhoni-WyDpVCLcWRAMfs5ouac9MJzxT-rsnLPw8,34226
@@ -46,9 +46,9 @@ lemonade/tools/report/llm_report.py,sha256=bVHhwCINA-Ok2EdSwAsLubsc83N3KWOVuwTgu
 lemonade/tools/report/table.py,sha256=Kv_Epd8a6KIrdzSC2EgIl6uTKw7E5eMq10Tg16O0WxM,27996
 lemonade/tools/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lemonade/tools/server/llamacpp.py,sha256=8HdTkrU2ht8L1ldXqkfYfYhXiA8TvySuaslinAMqr-c,9002
-lemonade/tools/server/serve.py,sha256=gwKPs-r-bfQsyCkVxzVyTp0SyNYVqqfMeeUFQ9TivwM,61638
+lemonade/tools/server/serve.py,sha256=W6wugCEaRNsDpWKIcsACrKZRFEwt7H1qWr6kG07WCek,62739
 lemonade/tools/server/tool_calls.py,sha256=xrAlQwKG-nv2xLlf8f9CDSaUbyMn8ZtHkds9iZLG9K8,5230
-lemonade/tools/server/tray.py,sha256=a9z6hdqlfj91H00j6hAExRPQkzWHhE3dnqSumzEgq0U,19599
+lemonade/tools/server/tray.py,sha256=2PQxoEWH-zzUGlveTW4heij4UC9SzxXcFlGs0JtFjF0,22226
 lemonade/tools/server/webapp.py,sha256=8Das5yXOaSBLZmSZ_eddJajQFxBhvl5D6GI_hHlGbE0,1040
 lemonade/tools/server/wrapped_server.py,sha256=DlzsGUwLQzjOFRfTTxfnhvmM_9lvAki96jWIAz7Czds,16713
 lemonade/tools/server/static/favicon.ico,sha256=hMmP9qGJNeZ0mFS86JIqPbZstXMZn0Z76_HfHQpREAU,126745
@@ -63,15 +63,15 @@ lemonade/tools/server/utils/system_tray.py,sha256=b9lvNv9chJKQxvmH7qzAuUe6H9HsLu
 lemonade/tools/server/utils/thread.py,sha256=Z-PDzGcpgfN2qxTmtlROWqrUN0B2fXdPrqo_J10fR_w,2772
 lemonade_install/__init__.py,sha256=26zohKg2jgr_5y7tObduWMYQg8zCTWMZHL8lfi2zZVQ,40
 lemonade_install/install.py,sha256=Dow7kt-K9WI4PH15hBwkKtOxede3dAaOmH4I1y_P5H4,27008
-lemonade_sdk-8.1.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lemonade_sdk-8.1.9.dist-info/licenses/NOTICE.md,sha256=RSca9LE5e6pvdWA_LXAUCcACIHPmINKqkRX-AVRqBGo,3499
-lemonade_server/cli.py,sha256=IsyWGDIeiN0MnIaBryLhArHhPj1HD52l6028dNHQCKc,19248
+lemonade_sdk-8.1.10.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lemonade_sdk-8.1.10.dist-info/licenses/NOTICE.md,sha256=RSca9LE5e6pvdWA_LXAUCcACIHPmINKqkRX-AVRqBGo,3499
+lemonade_server/cli.py,sha256=0Ht82D1z4Z2MuxTc07jF2glaegX4jT3Jh--sS6ZO6Qc,19302
 lemonade_server/model_manager.py,sha256=V8QRf1nlh3wAFtUHoSF_JeAXeR7sfaZE1uTfppcIfcw,20492
 lemonade_server/pydantic_models.py,sha256=49MyOlb5feLUlKsGcI75tWaflWckrItqcSVkdCY4e3A,3269
 lemonade_server/server_models.json,sha256=0H_G6Jw6Yuz6t0RZnFnq0SbBCsw_cQLe9j24TkyF2eI,12344
-lemonade_server/settings.py,sha256=6nsmPLFJD-UokQDmlx9ZBYMbpnn48So_PuBGWP7Fmfg,1299
-lemonade_sdk-8.1.9.dist-info/METADATA,sha256=rG009a2eVI1apZTBLwIcyQNwdYuVmX33naZwN8Rhbbs,15022
-lemonade_sdk-8.1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lemonade_sdk-8.1.9.dist-info/entry_points.txt,sha256=7sRvpNhi1E7amnM7RZo57e8yFF9iA5uuRaIeJ1Xre6w,193
-lemonade_sdk-8.1.9.dist-info/top_level.txt,sha256=10ap5GNiPhalO4V50LRoxA1FqRT9g3Xkia6BITu880k,42
-lemonade_sdk-8.1.9.dist-info/RECORD,,
+lemonade_server/settings.py,sha256=JOlZmirUXO9rA6BCODVFwyXrrHtYoH_LiKYm49lGm_c,1260
+lemonade_sdk-8.1.10.dist-info/METADATA,sha256=EYovzTHGnvWEZI-v_Gg1X0ajXeXiQPydqOkisnh08ME,15023
+lemonade_sdk-8.1.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lemonade_sdk-8.1.10.dist-info/entry_points.txt,sha256=7sRvpNhi1E7amnM7RZo57e8yFF9iA5uuRaIeJ1Xre6w,193
+lemonade_sdk-8.1.10.dist-info/top_level.txt,sha256=10ap5GNiPhalO4V50LRoxA1FqRT9g3Xkia6BITu880k,42
+lemonade_sdk-8.1.10.dist-info/RECORD,,

lemonade_server/cli.py

@@ -375,9 +375,11 @@ def is_lemonade_server(pid):
             if process_name in [  # Windows
                 "lemonade-server-dev.exe",
                 "lemonade-server.exe",
+                "lsdev.exe",
             ] or process_name in [  # Linux
                 "lemonade-server-dev",
                 "lemonade-server",
+                "lsdev",
             ]:
                 return True
             elif "llama-server" in process_name:

lemonade_server/settings.py

@@ -1,39 +1,39 @@
-import json
-import os
-from lemonade.cache import DEFAULT_CACHE_DIR
-
-# Define the path for the user settings file, placing it in the cache directory
-USER_SETTINGS_FILE = os.path.join(DEFAULT_CACHE_DIR, "user_settings.json")
-
-
-def save_setting(key, value):
-    """Save a setting to the user_settings.json file."""
-    # Ensure the cache directory exists
-    os.makedirs(DEFAULT_CACHE_DIR, exist_ok=True)
-
-    settings = {}
-    if os.path.exists(USER_SETTINGS_FILE):
-        with open(USER_SETTINGS_FILE, "r") as f:
-            try:
-                settings = json.load(f)
-            except json.JSONDecodeError:
-                # If the file is empty or corrupt, start with a fresh dictionary
-                pass
-
-    settings[key] = value
-    with open(USER_SETTINGS_FILE, "w") as f:
-        json.dump(settings, f, indent=4)
-
-
-def load_setting(key, default=None):
-    """Load a setting from the user_settings.json file."""
-    if not os.path.exists(USER_SETTINGS_FILE):
-        return default
-
-    with open(USER_SETTINGS_FILE, "r") as f:
-        try:
-            settings = json.load(f)
-            return settings.get(key, default)
-        except json.JSONDecodeError:
-            # Return default if the file is empty or corrupt
-            return default
+import json
+import os
+from lemonade.cache import DEFAULT_CACHE_DIR
+
+# Define the path for the user settings file, placing it in the cache directory
+USER_SETTINGS_FILE = os.path.join(DEFAULT_CACHE_DIR, "user_settings.json")
+
+
+def save_setting(key, value):
+    """Save a setting to the user_settings.json file."""
+    # Ensure the cache directory exists
+    os.makedirs(DEFAULT_CACHE_DIR, exist_ok=True)
+
+    settings = {}
+    if os.path.exists(USER_SETTINGS_FILE):
+        with open(USER_SETTINGS_FILE, "r") as f:
+            try:
+                settings = json.load(f)
+            except json.JSONDecodeError:
+                # If the file is empty or corrupt, start with a fresh dictionary
+                pass
+
+    settings[key] = value
+    with open(USER_SETTINGS_FILE, "w") as f:
+        json.dump(settings, f, indent=4)
+
+
+def load_setting(key, default=None):
+    """Load a setting from the user_settings.json file."""
+    if not os.path.exists(USER_SETTINGS_FILE):
+        return default
+
+    with open(USER_SETTINGS_FILE, "r") as f:
+        try:
+            settings = json.load(f)
+            return settings.get(key, default)
+        except json.JSONDecodeError:
+            # Return default if the file is empty or corrupt
+            return default