updated

app.py

@@ -372,7 +372,7 @@ def create_app():
                     progress_text,
                     gr.update(interactive=True)
                 )
-            elif "⚠️" in status_msg:
+            elif "⚠️" in status_msg or "cancelled" in status_msg.lower():
                 return (
                     '<div class="status-warning">⚠️ Download cancelled</div>',
                     progress_text,

src/config.py

@@ -108,22 +108,28 @@ def get_cached_checkpoints():
 
 
 def get_cached_vaes():
-    """Get list of cached VAE files (model_id_*_vae.safetensors)."""
+    """Get list of cached VAE files (model_id_vae.safetensors or model_id_*_vae.safetensors)."""
     if not CACHE_DIR.exists():
         return []
 
     models = []
+    # Match both patterns:
+    # - model_id_vae.safetensors
+    # - model_id_name_vae.safetensors (for backward compatibility)
     for file in sorted(CACHE_DIR.glob("*_vae.safetensors")):
         models.append(str(file))
     return models
 
 
 def get_cached_loras():
-    """Get list of cached LoRA files (model_id_*_lora.safetensors)."""
+    """Get list of cached LoRA files (model_id_lora.safetensors or model_id_*_lora.safetensors)."""
     if not CACHE_DIR.exists():
         return []
 
     models = []
+    # Match both patterns:
+    # - model_id_lora.safetensors
+    # - model_id_name_lora.safetensors (for backward compatibility)
     for file in sorted(CACHE_DIR.glob("*_lora.safetensors")):
         models.append(str(file))
     return models

src/downloader.py

@@ -27,8 +27,8 @@ def get_safe_filename_from_url(
 
     Naming patterns:
     - Checkpoint (type_prefix='model'): 12345_model.safetensors or 12345_model_anime_style.safetensors
-    - VAE (suffix='_vae'): 12345_vae.safetensors or 12345_anime_vae.safetensors
-    - LoRA (suffix='_lora'): 12345_lora.safetensors or 12345_name_lora.safetensors
+    - VAE (suffix='_vae'): 12345_vae.safetensors (no name extraction to avoid double suffix)
+    - LoRA (suffix='_lora'): 12345_lora.safetensors (no name extraction to avoid double suffix)
 
     For HuggingFace URLs without model IDs, attempts to extract name from path or uses suffix-based naming.
 
@@ -39,10 +39,10 @@ def get_safe_filename_from_url(
         type_prefix: Optional prefix after model_id (e.g., 'model' -> 12345_model.safetensors)
     """
     model_id = extract_model_id(url)
-    
+
     # If no CivitAI model ID, try to generate a name from HuggingFace path
     if not model_id and "huggingface.co" in url:
-        # Try to extract name from URL path (e.g., sdxl-vae-fp16-fix -> vae)
+        # Try to extract name from URL path (e.g., sdxl-vae-fp16-fix -> fp16_fix)
         try:
             parts = url.split("huggingface.co/")[1] if "huggingface.co/" in url else ""
             if parts:
@@ -56,17 +56,35 @@ def get_safe_filename_from_url(
                         model_id = f"hf_{clean_repo}"
         except Exception:
             pass
-    
+
     if not model_id:
         return default_name
 
-    # Build the name portion: either clean name from URL or fallback
-    name_part = ""
-    
-    # For VAE/LoRA types, prefer the suffix-based naming and skip Content-Disposition parsing
-    # to avoid double naming (e.g., sdxlvae_vae instead of just vae)
+    # Special handling for VAE/LoRA with HuggingFace URLs to avoid double suffix
     is_special_type = suffix in ("_vae", "_lora")
     
+    # Strip common suffixes from model_id when adding corresponding suffix
+    # (e.g., "sdxl_vae_fp16_fix" + "_vae" -> "sdxl_fp16_fix" + "_vae")
+    if is_special_type:
+        strip_suffix = suffix.lstrip('_')  # "vae" or "lora"
+        model_id_lower = model_id.lower()
+        # Check if model_id contains the type (with underscore boundaries)
+        if f"_{strip_suffix}_" in model_id_lower or model_id_lower.endswith(f"_{strip_suffix}"):
+            # Remove the suffix from model_id
+            if model_id_lower.endswith(f"_{strip_suffix}"):
+                model_id = model_id[:-len(strip_suffix)-1]
+            else:
+                # Find and remove _suffix_ pattern
+                pattern = f"_{strip_suffix}_"
+                idx = model_id_lower.find(pattern)
+                if idx >= 0:
+                    model_id = model_id[:idx] + model_id[idx+len(pattern):]
+
+    # Build the name portion: either clean name from URL or fallback
+    name_part = ""
+
+    # For VAE/LoRA types, skip Content-Disposition parsing to avoid double naming
+    # (e.g., sdxl_vae_vae instead of just vae)
     if not is_special_type:
         try:
             response = requests.head(url, timeout=10, allow_redirects=True)
@@ -90,19 +108,22 @@ def get_safe_filename_from_url(
         parts.append(type_prefix)
     if name_part:
         parts.append(name_part)
+
+    # Handle suffix - for VAE/LoRA we only add the suffix, not double naming
     if suffix:
-        # Avoid double underscores: only add separator if needed
-        if not suffix.startswith('_'):
-            parts.append('_' + suffix.lstrip('_'))
+        if is_special_type:
+            # For _vae and _lora: just use model_id + suffix directly
+            return f"{model_id}{suffix}.safetensors"
         else:
-            parts.append(suffix)
+            # For other types (checkpoint), append suffix after name_part
+            parts.append(suffix.lstrip('_'))
 
     return '_'.join(p for p in parts if p).replace('__', '_') + '.safetensors'
 
 
 class TqdmGradio(TqdmBase):
     """tqdm subclass that sends progress updates to Gradio's gr.Progress()"""
-    
+
     def __init__(self, *args, gradio_prog=None, **kwargs):
         super().__init__(*args, **kwargs)
         self.gradio_prog = gradio_prog
@@ -130,7 +151,7 @@ def set_download_cancelled(value: bool):
 def get_cached_file_size(url: str, suffix: str = "", type_prefix: str | None = None) -> tuple[Path | None, int | None]:
     """
     Check if file exists in cache and matches expected size.
-    
+
     Uses the same filename generation logic as download operations to find
     cached files by URL.
 
@@ -144,21 +165,21 @@ def get_cached_file_size(url: str, suffix: str = "", type_prefix: str | None = N
         or (None, None) if no valid cache found.
     """
     from .config import CACHE_DIR
-    
+
     # Generate the expected filename for this URL
     default_name = "vae.safetensors" if suffix == "_vae" else (
         "lora.safetensors" if suffix == "_lora" else "model.safetensors"
     )
-    
+
     cached_filename = get_safe_filename_from_url(
-        url, 
+        url,
         default_name=default_name,
         suffix=suffix,
         type_prefix=type_prefix
     )
-    
+
     cached_path = CACHE_DIR / cached_filename
-    
+
     if cached_path.exists() and cached_path.is_file():
         try:
             file_size = cached_path.stat().st_size
@@ -167,14 +188,14 @@ def get_cached_file_size(url: str, suffix: str = "", type_prefix: str | None = N
                 return cached_path, file_size
         except OSError:
             pass
-    
+
     return None, None
 
 
 def download_file_with_progress(url: str, output_path: Path, progress_bar=None) -> Path:
     """
     Download a file with Gradio-synced progress bar + cancel support.
-    
+
     Checks for existing cached files before downloading. If a valid cache
     exists (file exists with matching expected size), skips re-download.
 
@@ -215,7 +236,7 @@ def download_file_with_progress(url: str, output_path: Path, progress_bar=None)
         expected_size = int(head.headers.get('content-length', 0))
     except Exception:
         pass  # Skip header fetch on errors
-    
+
     if output_path.exists() and expected_size is not None:
         try:
             cached_size = output_path.stat().st_size
@@ -267,7 +288,7 @@ def download_file_with_progress(url: str, output_path: Path, progress_bar=None)
 def clear_cache(cache_dir: Path = None, keep_extensions: list[str] = None):
     """
     Remove old cache files.
-    
+
     Args:
         cache_dir: Cache directory path (defaults to config.CACHE_DIR)
         keep_extensions: File extensions to preserve (default: ['.safetensors'])
@@ -275,14 +296,14 @@ def clear_cache(cache_dir: Path = None, keep_extensions: list[str] = None):
     if cache_dir is None:
         from .config import CACHE_DIR
         cache_dir = CACHE_DIR
-    
+
     if keep_extensions is None:
         keep_extensions = ['.safetensors']
-    
+
     # Remove temp files
     for file in cache_dir.glob("*.tmp"):
         file.unlink()
-    
+
     # Optional: age-based cleanup (7 days)
     # import time
     # cutoff = time.time() - 86400 * 7

src/pipeline.py

@@ -83,7 +83,7 @@ def load_pipeline(
 
         # Check if checkpoint is already cached
         checkpoint_cached = checkpoint_path.exists() and checkpoint_path.stat().st_size > 0
-        
+
         # VAE: Use suffix="_vae" and default to "vae.safetensors" for proper caching/dropdown matching
         vae_filename = get_safe_filename_from_url(vae_url, default_name="vae.safetensors", suffix="_vae") if vae_url.strip() else "vae.safetensors"
         vae_path = CACHE_DIR / vae_filename
@@ -92,10 +92,10 @@ def load_pipeline(
         # Download checkpoint (skips if already cached)
         if progress:
             progress(0.1, desc="Downloading base model..." if not checkpoint_cached else "Loading base model...")
-        
+
         status_msg = f"📥 Downloading {checkpoint_path.name}..." if not checkpoint_cached else f"✅ Using cached {checkpoint_path.name}"
         yield status_msg, "Starting download..."
-        
+
         if not checkpoint_cached:
             download_file_with_progress(checkpoint_url, checkpoint_path)
 
@@ -104,25 +104,27 @@ def load_pipeline(
             status_msg = f"📥 Downloading {vae_path.name}..." if not vae_cached else f"✅ Using cached {vae_path.name}"
             if progress:
                 progress(0.2, desc="Downloading VAE..." if not vae_cached else "Loading VAE...")
-            
+
             yield status_msg, f"Downloading VAE: {vae_path.name}" if not vae_cached else f"Using cached VAE: {vae_path.name}"
-            
+
             if not vae_cached:
                 download_file_with_progress(vae_url, vae_path)
-            vae = AutoencoderKL.from_single_file(str(vae_path), torch_dtype=dtype)
-        else:
-            vae = None
 
-        # Load base pipeline
+        # Load base pipeline (yield progress during this heavy operation)
+        yield "⚙️ Loading SDXL pipeline...", "Loading model weights into memory..."
         if progress:
             progress(0.4, desc="Loading SDXL pipeline...")
-        yield f"⚙️ Loading pipeline...", f"Using device: {device_description}"
+
         global_pipe = StableDiffusionXLPipeline.from_single_file(
             str(checkpoint_path),
             torch_dtype=dtype,
             use_safetensors=True,
             safety_checker=None,
         )
+        yield "⚙️ Pipeline loaded, setting up VAE...", f"Using device: {device_description}"
+        if progress:
+            progress(0.6, desc="Setting up VAE...")
+
         if vae:
             global_pipe.vae = vae.to(device=device, dtype=dtype)
 
@@ -141,7 +143,7 @@ def load_pipeline(
         if lora_urls:
             global_pipe = global_pipe.to(device=device, dtype=dtype)
             for i, (lora_url, strength) in enumerate(zip(lora_urls, strengths)):
-                lora_filename = get_safe_filename_from_url(lora_url, f"lora_{i}.safetensors", suffix="_lora")
+                lora_filename = get_safe_filename_from_url(lora_url, suffix="_lora")
                 lora_path = CACHE_DIR / lora_filename
                 lora_cached = lora_path.exists() and lora_path.stat().st_size > 0
                 
@@ -159,17 +161,25 @@ def load_pipeline(
                 
                 if not lora_cached:
                     download_file_with_progress(lora_url, lora_path)
+                
+                yield f"⚙️ Loading LoRA {i+1}/{len(lora_urls)}...", f"Fusing {lora_path.name}..."
+                if progress:
+                    progress(0.7 + (0.2 * i / len(lora_urls)), desc=f"Loading LoRA {i+1}/{len(lora_urls)}...")
+                
                 adapter_name = f"lora_{i}"
                 global_pipe.load_lora_weights(str(lora_path), adapter_name=adapter_name)
                 global_pipe.fuse_lora(adapter_names=[adapter_name], lora_scale=strength)
                 global_pipe.unload_lora_weights()
 
         # Set scheduler and move to device (do this once at the end)
-        yield "⚙️ Finalizing...", "Setting up scheduler..."
-        # Use existing scheduler, just update algorithm_type for DPM++ SDE
+        yield "⚙️ Finalizing pipeline...", "Setting up scheduler and moving to device..."
+        if progress:
+            progress(0.9, desc="Finalizing...")
+
         global_pipe.scheduler.config.algorithm_type = "sde-dpmsolver++"
         global_pipe = global_pipe.to(device=device, dtype=dtype)
 
+        yield "✅ Pipeline ready!", f"Ready! Loaded {len(lora_urls)} LoRA(s)"
         return ("✅ Pipeline loaded successfully!", f"Ready! Loaded {len(lora_urls)} LoRA(s)")
 
     except KeyboardInterrupt: