lemonade-sdk 8.1.5__py3-none-any.whl → 8.1.6__py3-none-any.whl

lemonade_server/cli.py

@@ -144,8 +144,12 @@ def stop():
                 except psutil.NoSuchProcess:
                     pass  # Child already terminated
 
-        # Wait for main process
-        process.wait(timeout=10)
+        # Wait for main process to terminate gracefully
+        # kill if it doesn't terminate gracefully
+        try:
+            process.wait(timeout=5)
+        except psutil.TimeoutExpired:
+            process.kill()
 
         # Kill llama-server child process if it didn't terminate gracefully
         for child in children:
@@ -273,6 +277,7 @@ def run(
     """
     import webbrowser
     import time
+    import os
 
     # Start the server if not running
     _, running_port = get_server_info()
@@ -299,7 +304,10 @@ def run(
     # Open the webapp with the specified model
     url = f"http://{host}:{port}/?model={model_name}#llm-chat"
     print(f"You can now chat with {model_name} at {url}")
-    webbrowser.open(url)
+
+    # Only open browser if not disabled via environment variable
+    if not os.environ.get("LEMONADE_DISABLE_BROWSER"):
+        webbrowser.open(url)
 
     # Keep the server running if we started it
     if not server_previously_running:
@@ -507,6 +515,13 @@ def _add_server_arguments(parser):
         default=DEFAULT_CTX_SIZE,
     )
 
+    if os.name == "nt":
+        parser.add_argument(
+            "--no-tray",
+            action="store_true",
+            help="Do not show a tray icon when the server is running",
+        )
+
 
 def main():
     parser = argparse.ArgumentParser(
@@ -527,12 +542,6 @@ def main():
     # Serve command
     serve_parser = subparsers.add_parser("serve", help="Start server")
     _add_server_arguments(serve_parser)
-    if os.name == "nt":
-        serve_parser.add_argument(
-            "--no-tray",
-            action="store_true",
-            help="Do not show a tray icon when the server is running",
-        )
 
     # Status command
     status_parser = subparsers.add_parser("status", help="Check if server is running")

lemonade_server/model_manager.py

@@ -77,15 +77,50 @@ class ModelManager:
     def downloaded_models(self) -> dict:
         """
         Returns a dictionary of locally available models.
+        For GGUF models with variants, checks if the specific variant files exist.
         """
         downloaded_models = {}
         downloaded_checkpoints = self.downloaded_hf_checkpoints
         for model in self.supported_models:
-            base_checkpoint = parse_checkpoint(
-                self.supported_models[model]["checkpoint"]
-            )[0]
+            model_info = self.supported_models[model]
+            checkpoint = model_info["checkpoint"]
+            base_checkpoint, variant = parse_checkpoint(checkpoint)
+
             if base_checkpoint in downloaded_checkpoints:
-                downloaded_models[model] = self.supported_models[model]
+                # For GGUF models with variants, verify the specific variant files exist
+                if variant and model_info.get("recipe") == "llamacpp":
+                    try:
+                        from lemonade.tools.llamacpp.utils import identify_gguf_models
+                        from lemonade.common.network import custom_snapshot_download
+
+                        # Get the local snapshot path
+                        snapshot_path = custom_snapshot_download(
+                            base_checkpoint, local_files_only=True
+                        )
+
+                        # Check if the specific variant files exist
+                        core_files, sharded_files = identify_gguf_models(
+                            base_checkpoint, variant, model_info.get("mmproj", "")
+                        )
+                        all_variant_files = list(core_files.values()) + sharded_files
+
+                        # Verify all required files exist locally
+                        all_files_exist = True
+                        for file_path in all_variant_files:
+                            full_file_path = os.path.join(snapshot_path, file_path)
+                            if not os.path.exists(full_file_path):
+                                all_files_exist = False
+                                break
+
+                        if all_files_exist:
+                            downloaded_models[model] = model_info
+
+                    except Exception:
+                        # If we can't verify the variant, don't include it
+                        pass
+                else:
+                    # For non-GGUF models or GGUF without variants, use the original logic
+                    downloaded_models[model] = model_info
         return downloaded_models
 
     @property
@@ -166,6 +201,53 @@ class ModelManager:
                     reasoning=reasoning,
                 )
             else:
+                # Model is already registered - check if trying to register with different parameters
+                existing_model = self.supported_models[model]
+                existing_checkpoint = existing_model.get("checkpoint")
+                existing_recipe = existing_model.get("recipe")
+                existing_reasoning = "reasoning" in existing_model.get("labels", [])
+                existing_mmproj = existing_model.get("mmproj", "")
+
+                # Compare parameters (handle None/empty string equivalence for mmproj)
+                checkpoint_differs = checkpoint and checkpoint != existing_checkpoint
+                recipe_differs = recipe and recipe != existing_recipe
+                reasoning_differs = reasoning != existing_reasoning
+                mmproj_differs = mmproj != existing_mmproj and not (
+                    not mmproj and not existing_mmproj
+                )
+
+                if (
+                    checkpoint_differs
+                    or recipe_differs
+                    or reasoning_differs
+                    or mmproj_differs
+                ):
+                    conflicts = []
+                    if checkpoint_differs:
+                        conflicts.append(
+                            f"checkpoint (existing: '{existing_checkpoint}', new: '{checkpoint}')"
+                        )
+                    if recipe_differs:
+                        conflicts.append(
+                            f"recipe (existing: '{existing_recipe}', new: '{recipe}')"
+                        )
+                    if reasoning_differs:
+                        conflicts.append(
+                            f"reasoning (existing: {existing_reasoning}, new: {reasoning})"
+                        )
+                    if mmproj_differs:
+                        conflicts.append(
+                            f"mmproj (existing: '{existing_mmproj}', new: '{mmproj}')"
+                        )
+
+                    conflict_details = ", ".join(conflicts)
+                    raise ValueError(
+                        f"Model {model} is already registered with different configuration. "
+                        f"Conflicting parameters: {conflict_details}. "
+                        f"Please use a different model name or delete the existing model first using "
+                        f"`lemonade-server delete {model}`."
+                    )
+
                 new_registration_model_config = None
 
             # Download the model
@@ -229,6 +311,7 @@ class ModelManager:
     def delete_model(self, model_name: str):
         """
         Deletes the specified model from local storage.
+        For GGUF models with variants, only deletes the specific variant files.
         """
         if model_name not in self.supported_models:
             raise ValueError(
@@ -239,36 +322,134 @@ class ModelManager:
         checkpoint = self.supported_models[model_name]["checkpoint"]
         print(f"Deleting {model_name} ({checkpoint})")
 
-        # Handle GGUF models that have the format "checkpoint:variant"
-        base_checkpoint = parse_checkpoint(checkpoint)[0]
+        # Parse checkpoint to get base and variant
+        base_checkpoint, variant = parse_checkpoint(checkpoint)
 
+        # Get the repository cache directory
+        snapshot_path = None
+        model_cache_dir = None
         try:
-            # Get the local path using snapshot_download with local_files_only=True
+            # First, try to get the local path using snapshot_download with local_files_only=True
             snapshot_path = custom_snapshot_download(
                 base_checkpoint, local_files_only=True
             )
-
             # Navigate up to the model directory (parent of snapshots directory)
-            model_path = os.path.dirname(os.path.dirname(snapshot_path))
-
-            # Delete the entire model directory (including all snapshots)
-            if os.path.exists(model_path):
-                shutil.rmtree(model_path)
-                print(f"Successfully deleted model {model_name} from {model_path}")
-            else:
-                raise ValueError(
-                    f"Model {model_name} not found locally at {model_path}"
-                )
+            model_cache_dir = os.path.dirname(os.path.dirname(snapshot_path))
 
         except Exception as e:
+            # If snapshot_download fails, try to construct the cache path manually
             if (
                 "not found in cache" in str(e).lower()
-                or "no such file" in str(e).lower()
+                or "localentrynotfounderror" in str(e).lower()
+                or "cannot find an appropriate cached snapshot" in str(e).lower()
             ):
-                raise ValueError(f"Model {model_name} is not installed locally")
+                # Construct the Hugging Face cache path manually
+                cache_home = huggingface_hub.constants.HF_HUB_CACHE
+                # Convert repo format (e.g., "unsloth/GLM-4.5-Air-GGUF") to cache format
+                repo_cache_name = base_checkpoint.replace("/", "--")
+                model_cache_dir = os.path.join(cache_home, f"models--{repo_cache_name}")
+                # Try to find the snapshot path within the model cache directory
+                if os.path.exists(model_cache_dir):
+                    snapshots_dir = os.path.join(model_cache_dir, "snapshots")
+                    if os.path.exists(snapshots_dir):
+                        snapshot_dirs = [
+                            d
+                            for d in os.listdir(snapshots_dir)
+                            if os.path.isdir(os.path.join(snapshots_dir, d))
+                        ]
+                        if snapshot_dirs:
+                            # Use the first (likely only) snapshot directory
+                            snapshot_path = os.path.join(
+                                snapshots_dir, snapshot_dirs[0]
+                            )
             else:
                 raise ValueError(f"Failed to delete model {model_name}: {str(e)}")
 
+        # Handle deletion based on whether this is a GGUF model with variants
+        if variant and snapshot_path and os.path.exists(snapshot_path):
+            # This is a GGUF model with a specific variant - delete only variant files
+            try:
+                from lemonade.tools.llamacpp.utils import identify_gguf_models
+
+                # Get the specific files for this variant
+                core_files, sharded_files = identify_gguf_models(
+                    base_checkpoint,
+                    variant,
+                    self.supported_models[model_name].get("mmproj", ""),
+                )
+                all_variant_files = list(core_files.values()) + sharded_files
+
+                # Delete the specific variant files
+                deleted_files = []
+                for file_path in all_variant_files:
+                    full_file_path = os.path.join(snapshot_path, file_path)
+                    if os.path.exists(full_file_path):
+                        if os.path.isfile(full_file_path):
+                            os.remove(full_file_path)
+                            deleted_files.append(file_path)
+                        elif os.path.isdir(full_file_path):
+                            shutil.rmtree(full_file_path)
+                            deleted_files.append(file_path)
+
+                if deleted_files:
+                    print(f"Successfully deleted variant files: {deleted_files}")
+                else:
+                    print(f"No variant files found for {variant} in {snapshot_path}")
+
+                # Check if the snapshot directory is now empty (only containing .gitattributes, README, etc.)
+                remaining_files = [
+                    f
+                    for f in os.listdir(snapshot_path)
+                    if f.endswith(".gguf")
+                    or os.path.isdir(os.path.join(snapshot_path, f))
+                ]
+
+                # If no GGUF files remain, we can delete the entire repository
+                if not remaining_files:
+                    print(f"No other variants remain, deleting entire repository cache")
+                    shutil.rmtree(model_cache_dir)
+                    print(
+                        f"Successfully deleted entire model cache at {model_cache_dir}"
+                    )
+                else:
+                    print(
+                        f"Other variants still exist in repository, keeping cache directory"
+                    )
+
+            except Exception as variant_error:
+                print(
+                    f"Warning: Could not perform selective variant deletion: {variant_error}"
+                )
+                print("This may indicate the files were already manually deleted")
+
+        elif model_cache_dir and os.path.exists(model_cache_dir):
+            # Non-GGUF model or GGUF without variant - delete entire repository as before
+            shutil.rmtree(model_cache_dir)
+            print(f"Successfully deleted model {model_name} from {model_cache_dir}")
+
+        elif model_cache_dir:
+            # Model directory doesn't exist - it was likely already manually deleted
+            print(
+                f"Model {model_name} directory not found at {model_cache_dir} - may have been manually deleted"
+            )
+
+        else:
+            raise ValueError(f"Unable to determine cache path for model {model_name}")
+
+        # Clean up user models registry if applicable
+        if model_name.startswith("user.") and os.path.exists(USER_MODELS_FILE):
+            with open(USER_MODELS_FILE, "r", encoding="utf-8") as file:
+                user_models = json.load(file)
+
+            # Remove the "user." prefix to get the actual model name in the file
+            base_model_name = model_name[5:]  # Remove "user." prefix
+
+            if base_model_name in user_models:
+                del user_models[base_model_name]
+                with open(USER_MODELS_FILE, "w", encoding="utf-8") as file:
+                    json.dump(user_models, file)
+                print(f"Removed {model_name} from user models registry")
+
 
 # This file was originally licensed under Apache 2.0. It has been modified.
 # Modifications Copyright (c) 2025 AMD