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

lemonade/cli.py

@@ -12,6 +12,41 @@ from lemonade.sequence import Sequence
 from lemonade.tools.management_tools import Cache, Version, SystemInfo
 from lemonade.state import State
 
+
+def get_available_profilers(warn_missing=False):
+    """Get list of available profilers, with conditional imports for optional dependencies.
+
+    Args:
+        warn_missing: If True, print warnings for missing profilers. If False, fail silently.
+    """
+    profilers = [MemoryTracker]
+
+    try:
+        from lemonade.profilers.hwinfo_power import HWINFOPowerProfiler
+
+        profilers.append(HWINFOPowerProfiler)
+    except ImportError:
+        if warn_missing:
+            print(
+                "Warning: HWINFOPowerProfiler not available. "
+                "Install lemonade with dev extras: "
+                "pip install lemonade-sdk[dev]"
+            )
+    try:
+        from lemonade.profilers.agt_power import AGTPowerProfiler
+
+        profilers.append(AGTPowerProfiler)
+    except ImportError:
+        if warn_missing:
+            print(
+                "Warning: AGTPowerProfiler not available. "
+                "Install lemonade with dev extras: "
+                "pip install lemonade-sdk[dev]"
+            )
+
+    return profilers
+
+
 from lemonade.tools.huggingface.load import HuggingfaceLoad
 from lemonade.tools.huggingface.bench import HuggingfaceBench
 from lemonade.tools.oga.load import OgaLoad
@@ -51,7 +86,7 @@ def main():
     ]
 
     # List the available profilers
-    profilers = [MemoryTracker]
+    profilers = get_available_profilers()
 
     # Define the argument parser
     parser = cli.CustomArgumentParser(
@@ -85,6 +120,17 @@ https://github.com/lemonade-sdk/lemonade/blob/main/docs/README.md""",
         parser, tools, cli_name="lemonade"
     )
 
+    # Check if any profilers are being requested
+    requested_profilers = [
+        profiler.unique_name.replace("-", "_")
+        for profiler in profilers
+        if global_args.get(profiler.unique_name.replace("-", "_"), None) is not None
+    ]
+
+    # If profilers are requested, get the full list with warnings for missing ones
+    if requested_profilers:
+        get_available_profilers(warn_missing=True)
+
     profiler_instances = [
         profiler(global_args[profiler.unique_name.replace("-", "_")])
         for profiler in profilers

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: