cleaned up code

.env.example

@@ -0,0 +1,12 @@
+# SDXL Model Merger - Environment Configuration Example
+# Copy this to .env and customize for your deployment
+
+# Deployment Environment (auto-detected: local, spaces)
+DEPLOYMENT_ENV=local
+
+# Default Model URLs - Use HF models for Spaces compatibility
+DEFAULT_CHECKPOINT_URL=https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors?download=true
+DEFAULT_VAE_URL=https://huggingface.co/madebyollin/sdxl-vae-fp16-fix/resolve/main/sdxl.vae.safetensors?download=true
+
+# Default LoRA - using HF instead of CivitAI (may not be accessible on Spaces)
+DEFAULT_LORA_URLS=https://huggingface.co/nerijs/pixel-art-xl/resolve/main/pixel-art-xl.safetensors?download=true

app.py

@@ -78,7 +78,7 @@ def create_app():
     }
     """
 
-    from src.pipeline import load_pipeline, cancel_download
+    from src.pipeline import load_pipeline
     from src.generator import generate_image
     from src.exporter import export_merged_model
     from src.config import get_cached_models, get_cached_checkpoints, get_cached_vaes, get_cached_loras
@@ -227,7 +227,7 @@ def create_app():
                     )
 
                     cfg = gr.Slider(
-                        minimum=1.0, maximum=20.0, value=7.5, step=0.5,
+                        minimum=1.0, maximum=20.0, value=3.0, step=0.5,
                         label="CFG Scale",
                         info="Higher values make outputs match prompt more strictly"
                     )
@@ -247,7 +247,7 @@ def create_app():
                     )
 
                     steps = gr.Slider(
-                        minimum=1, maximum=100, value=25, step=1,
+                        minimum=1, maximum=100, value=8, step=1,
                         label="Inference Steps",
                         info="More steps = better quality but slower"
                     )
@@ -262,6 +262,13 @@ def create_app():
                 tile_x = gr.Checkbox(True, label="X-axis Seamless Tiling")
                 tile_y = gr.Checkbox(False, label="Y-axis Seamless Tiling")
 
+            seed = gr.Number(
+                value=80484030936239,
+                precision=0,
+                label="Seed",
+                info="Random seed for reproducible generation"
+            )
+
             with gr.Row():
                 gen_btn = gr.Button("✨ Generate Image", variant="secondary", size="lg")
 
@@ -361,8 +368,7 @@ def create_app():
             return (
                 '<div class="status-warning">⏳ Loading started...</div>',
                 "Starting download...",
-                gr.update(interactive=False),
-                gr.update(visible=True)
+                gr.update(interactive=False)
             )
 
         def on_load_pipeline_complete(status_msg, progress_text):
@@ -371,44 +377,34 @@ def create_app():
                 return (
                     '<div class="status-success">✅ Pipeline loaded successfully!</div>',
                     progress_text,
-                    gr.update(interactive=True),
-                    gr.update(visible=False)
+                    gr.update(interactive=True)
                 )
             elif "⚠️" in status_msg or "cancelled" in status_msg.lower():
                 return (
                     '<div class="status-warning">⚠️ Download cancelled</div>',
                     progress_text,
-                    gr.update(interactive=True),
-                    gr.update(visible=False)
+                    gr.update(interactive=True)
                 )
             else:
                 return (
                     f'<div class="status-error">{status_msg}</div>',
                     progress_text,
-                    gr.update(interactive=True),
-                    gr.update(visible=False)
+                    gr.update(interactive=True)
                 )
 
-        # Cancel button for pipeline loading
-        cancel_load_btn = gr.Button("🛑 Cancel Loading", variant="secondary", size="sm", visible=False)
-
         load_btn.click(
             fn=on_load_pipeline_start,
             inputs=[],
-            outputs=[load_status, load_progress, load_btn, cancel_load_btn],
+            outputs=[load_status, load_progress, load_btn],
         ).then(
             fn=load_pipeline,
             inputs=[checkpoint_url, vae_url, lora_urls, lora_strengths],
             outputs=[load_status, load_progress],
             show_progress="full",
-        ).then(
-            fn=lambda: (gr.update(interactive=True), gr.update(visible=False)),
-            inputs=[],
-            outputs=[cancel_load_btn, cancel_load_btn],  # Just to hide it
         ).then(
             fn=on_load_pipeline_complete,
             inputs=[load_status, load_progress],
-            outputs=[load_status, load_progress, load_btn, cancel_load_btn],
+            outputs=[load_status, load_progress, load_btn],
         ).then(
             fn=lambda: (
                 gr.update(choices=["(None found)"] + get_cached_checkpoints()),
@@ -419,17 +415,6 @@ def create_app():
             outputs=[cached_checkpoints, cached_vaes, cached_loras],
         )
 
-        # Cancel button handler
-        cancel_load_btn.click(
-            fn=lambda: (cancel_download(), 
-                       '<div class="status-warning">⏳ Cancelling...</div>',
-                       "Cancelling download...",
-                       gr.update(visible=False),
-                       gr.update(interactive=True)),
-            inputs=[],
-            outputs=[load_status, load_progress, cancel_load_btn, load_btn],
-        )
-
         def on_cached_checkpoint_change(cached_path):
             """Update URL when a cached checkpoint is selected."""
             if cached_path and cached_path != "(None found)":
@@ -502,7 +487,7 @@ def create_app():
             outputs=[gen_status, gen_progress, gen_btn],
         ).then(
             fn=generate_image,
-            inputs=[prompt, negative_prompt, cfg, steps, height, width, tile_x, tile_y],
+            inputs=[prompt, negative_prompt, cfg, steps, height, width, tile_x, tile_y, seed],
             outputs=[image_output, gen_progress],
         ).then(
             fn=lambda img, msg: on_generate_complete(msg, "Done", img),
@@ -543,7 +528,7 @@ def create_app():
             fn=lambda inc, q, qt, fmt: export_merged_model(
                 include_lora=inc,
                 quantize=q and (qt != "none"),
-                qtype=qt if qt != "none" else None,
+                qtype=qt,  # always pass the string value; exporter handles "none" correctly
                 save_format=fmt,
             ),
             inputs=[include_lora, quantize_toggle, qtype_dropdown, format_dropdown],

manifest.json

@@ -0,0 +1 @@
+{"name": "SDXL Model Merger", "short_name": "SDXL Merger", "description": "Merge SDXL checkpoints, LoRAs, and VAEs with optional quantization", "start_url": "/", "display": "standalone", "background_color": "#ffffff", "theme_color": "#10b981"}

src/config.py

@@ -114,11 +114,43 @@ print(f"🚀 Using device: {device_description}")
 check_memory_requirements()
 
 # ──────────────────────────────────────────────
-# Global State
+# Global Pipeline State
+#
+# IMPORTANT: Use get_pipe() / set_pipe() instead of importing `pipe` directly.
+# Python's `from .config import pipe` binds the value (None) at import time.
+# Subsequent set_pipe() calls update the mutable dict, so all modules that
+# call get_pipe() will always see the current pipeline instance.
 # ──────────────────────────────────────────────
+_pipeline_state: dict = {"pipe": None}
+
+
+def get_pipe():
+    """Get the currently loaded pipeline instance (always up-to-date)."""
+    return _pipeline_state["pipe"]
+
+
+def set_pipe(pipeline) -> None:
+    """Set the globally loaded pipeline instance."""
+    _pipeline_state["pipe"] = pipeline
+
+
+# Legacy alias kept for any code that references config.pipe directly.
+# Do NOT use this for checking whether the pipeline is loaded — use get_pipe().
 pipe = None
+
+
+# ──────────────────────────────────────────────
+# Download Cancellation Flag
+# ──────────────────────────────────────────────
 download_cancelled = False
 
+
+def set_download_cancelled(value: bool) -> None:
+    """Set the global download cancellation flag."""
+    global download_cancelled
+    download_cancelled = value
+
+
 # ──────────────────────────────────────────────
 # Generation Defaults
 # ──────────────────────────────────────────────

src/downloader.py

@@ -135,7 +135,7 @@ class TqdmGradio(TqdmBase):
         self.last_pct = 0
 
     def update(self, n=1):
-        global download_cancelled
+        from .config import download_cancelled
         if download_cancelled:
             raise KeyboardInterrupt("Download cancelled by user")
         super().update(n)
@@ -147,12 +147,6 @@ class TqdmGradio(TqdmBase):
                 self.gradio_prog(pct / 100)
 
 
-def set_download_cancelled(value: bool):
-    """Set the global download cancellation flag."""
-    global download_cancelled
-    download_cancelled = value
-
-
 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.
@@ -218,7 +212,7 @@ def download_file_with_progress(url: str, output_path: Path, progress_bar=None)
         KeyboardInterrupt: If download is cancelled
         requests.RequestException: If download fails
     """
-    global download_cancelled
+    from .config import download_cancelled
 
     # Handle local file:// URLs
     if url.startswith("file://"):

src/exporter.py

@@ -6,7 +6,8 @@ from pathlib import Path
 import torch
 from safetensors.torch import save_file
 
-from .config import SCRIPT_DIR, pipe as global_pipe
+from . import config
+from .config import SCRIPT_DIR
 
 
 def export_merged_model(
@@ -14,7 +15,7 @@ def export_merged_model(
     quantize: bool,
     qtype: str,
     save_format: str = "safetensors",
-) -> tuple[str | None, str]:
+):
     """
     Export the merged pipeline model with optional LoRA baking and quantization.
 
@@ -24,56 +25,66 @@ def export_merged_model(
         qtype: Quantization type - 'none', 'int8', 'int4', or 'float8'
         save_format: Output format - 'safetensors' or 'bin'
 
+    Yields:
+        Tuple of (status_message, progress_text) at each export stage.
+
     Returns:
-        Tuple of (output_path or None, status message)
+        Final yielded tuple of (output_path or None, status message)
     """
-    if not global_pipe:
-        return None, "⚠️ Please load a pipeline first."
+    # Fetch the pipeline at call time — avoids the stale import-by-value problem.
+    pipe = config.get_pipe()
+
+    if not pipe:
+        yield None, "⚠️ Please load a pipeline first."
+        return
 
     try:
         # Validate quantization type
         valid_qtypes = ("none", "int8", "int4", "float8")
         if qtype not in valid_qtypes:
-            return None, f"❌ Invalid quantization type: {qtype}. Must be one of: {valid_qtypes}"
+            yield None, f"❌ Invalid quantization type: {qtype}. Must be one of: {valid_qtypes}"
+            return
 
         # Step 1: Unload LoRAs
         yield "💾 Exporting model...", "Unloading LoRAs..."
         if include_lora:
             try:
-                global_pipe.unload_lora_weights()
+                pipe.unload_lora_weights()
             except Exception as e:
                 print(f"  ℹ️ Could not unload LoRAs: {e}")
-                pass
 
         merged_state_dict = {}
 
         # Step 2: Extract UNet weights
         yield "💾 Exporting model...", "Extracting UNet weights..."
-        for k, v in global_pipe.unet.state_dict().items():
+        for k, v in pipe.unet.state_dict().items():
             merged_state_dict[f"unet.{k}"] = v.contiguous().half()
 
         # Step 3: Extract text encoder weights
         yield "💾 Exporting model...", "Extracting text encoders..."
-        for k, v in global_pipe.text_encoder.state_dict().items():
-            merged_state_dict[f"text_encoder.{k}"] = v.contiguous().half()
-        for k, v in global_pipe.text_encoder_2.state_dict().items():
-            merged_state_dict[f"text_encoder_2.{k}"] = v.contiguous().half()
+        if pipe.text_encoder is not None:
+            for k, v in pipe.text_encoder.state_dict().items():
+                merged_state_dict[f"text_encoder.{k}"] = v.contiguous().half()
+        if pipe.text_encoder_2 is not None:
+            for k, v in pipe.text_encoder_2.state_dict().items():
+                merged_state_dict[f"text_encoder_2.{k}"] = v.contiguous().half()
 
         # Step 4: Extract VAE weights
         yield "💾 Exporting model...", "Extracting VAE weights..."
-        for k, v in global_pipe.vae.state_dict().items():
-            merged_state_dict[f"first_stage_model.{k}"] = v.contiguous().half()
+        if pipe.vae is not None:
+            for k, v in pipe.vae.state_dict().items():
+                merged_state_dict[f"first_stage_model.{k}"] = v.contiguous().half()
 
         # Step 5: Quantize if requested and optimum.quanto is available
         try:
-            from optimum.quanto import quantize, QTensor
+            from optimum.quanto import quantize as quanto_quantize, QTensor
             QUANTO_AVAILABLE = True
         except ImportError:
             QUANTO_AVAILABLE = False
 
         if quantize and qtype != "none" and QUANTO_AVAILABLE:
             yield "💾 Exporting model...", f"Applying {qtype} quantization..."
-            
+
             class FakeModel(torch.nn.Module):
                 pass
 
@@ -83,13 +94,13 @@ def export_merged_model(
             # Select quantization method
             if qtype == "int8":
                 from optimum.quanto import int8_weight_only
-                quantize(fake_model, int8_weight_only())
+                quanto_quantize(fake_model, int8_weight_only())
             elif qtype == "int4":
                 from optimum.quanto import int4_weight_only
-                quantize(fake_model, int4_weight_only())
+                quanto_quantize(fake_model, int4_weight_only())
             elif qtype == "float8":
                 from optimum.quanto import float8_dynamic_activation_float8_weight
-                quantize(fake_model, float8_dynamic_activation_float8_weight())
+                quanto_quantize(fake_model, float8_dynamic_activation_float8_weight())
             else:
                 raise ValueError(f"Unsupported qtype: {qtype}")
 
@@ -98,11 +109,12 @@ def export_merged_model(
                 for k, v in fake_model.state_dict().items()
             }
         elif quantize and not QUANTO_AVAILABLE:
-            return None, "❌ optimum.quanto not installed. Install with: pip install optimum-quanto"
+            yield None, "❌ optimum.quanto not installed. Install with: pip install optimum-quanto"
+            return
 
         # Step 6: Save model
         yield "💾 Exporting model...", "Saving weights..."
-        
+
         ext = ".bin" if save_format == "bin" else ".safetensors"
 
         # Build filename based on options
@@ -125,13 +137,14 @@ def export_merged_model(
         else:
             msg = f"✅ Merged checkpoint saved: `{out_path}` ({size_gb:.2f} GB)"
 
-        yield "💾 Exporting model...", msg
-        return str(out_path), msg
+        yield str(out_path), msg
 
     except ImportError as e:
-        return None, f"❌ Missing dependency: {str(e)}"
+        yield None, f"❌ Missing dependency: {str(e)}"
     except Exception as e:
-        return None, f"❌ Export failed: {str(e)}"
+        import traceback
+        print(traceback.format_exc())
+        yield None, f"❌ Export failed: {str(e)}"
 
 
 def get_export_status() -> str:

src/generator.py

@@ -2,8 +2,9 @@
 
 import torch
 
-from .config import device, dtype, pipe as global_pipe, is_running_on_spaces
-from .pipeline import enable_seamless_tiling
+from . import config
+from .config import device, dtype, is_running_on_spaces
+from .tiling import enable_seamless_tiling
 
 
 def generate_image(
@@ -15,7 +16,8 @@ def generate_image(
     width: int,
     tile_x: bool = True,
     tile_y: bool = False,
-) -> tuple[object | None, str]:
+    seed: int | None = None,
+):
     """
     Generate an image using the loaded SDXL pipeline.
 
@@ -28,49 +30,67 @@ def generate_image(
         width: Output image width in pixels
         tile_x: Enable seamless tiling on x-axis
         tile_y: Enable seamless tiling on y-axis
+        seed: Random seed for reproducibility (default: uses timestamp-based seed)
 
-    Returns:
-        Tuple of (PIL Image or None, status message)
+    Yields:
+        Tuple of (intermediate_image_or_none, status_message)
+        - First yield: (None, progress_text) for initial progress update
+        - Final yield: (PIL Image, final_status) with the generated image,
+          or (None, error_message) if generation failed.
     """
-    if not global_pipe:
-        return None, "⚠️ Please load a pipeline first."
+    # Fetch the pipeline at call time — avoids the stale import-by-value problem.
+    pipe = config.get_pipe()
+
+    if not pipe:
+        yield None, "⚠️ Please load a pipeline first."
+        return
 
     # For CPU mode, use float32 and warn about slow generation
     effective_dtype = dtype
     effective_device = device
-    
+
     if is_running_on_spaces() and device == "cpu":
         print("  ℹ️ CPU mode: using float32 for stability (generation will be slower)")
+        # Store original dtype and temporarily use float32
+        original_dtype = effective_dtype
         effective_dtype = torch.float32
         # Update pipeline to use float32
-        global_pipe.unet.to(dtype=torch.float32)
-        global_pipe.text_encoder.to(dtype=torch.float32)
-        global_pipe.text_encoder_2.to(dtype=torch.float32)
-        if global_pipe.vae:
-            global_pipe.vae.to(dtype=torch.float32)
+        pipe.unet.to(dtype=torch.float32)
+        if pipe.text_encoder is not None:
+            pipe.text_encoder.to(dtype=torch.float32)
+        if pipe.text_encoder_2 is not None:
+            pipe.text_encoder_2.to(dtype=torch.float32)
+        if pipe.vae is not None:
+            pipe.vae.to(dtype=torch.float32)
+    else:
+        original_dtype = None
 
     # Enable seamless tiling on UNet & VAE decoder
-    enable_seamless_tiling(global_pipe.unet, tile_x=tile_x, tile_y=tile_y)
-    enable_seamless_tiling(global_pipe.vae.decoder, tile_x=tile_x, tile_y=tile_y)
-
-    yield "🎨 Generating image...", f"Steps: 0/{steps} | CFG: {cfg}"
+    enable_seamless_tiling(pipe.unet, tile_x=tile_x, tile_y=tile_y)
+    enable_seamless_tiling(pipe.vae.decoder, tile_x=tile_x, tile_y=tile_y)
 
-    generator = torch.Generator(device=effective_device).manual_seed(42)  # Fixed seed for reproducibility
-    result = global_pipe(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        width=int(width),
-        height=int(height),
-        num_inference_steps=int(steps),
-        guidance_scale=float(cfg),
-        generator=generator,
-    )
+    yield None, "🎨 Generating image..."
 
-    image = result.images[0]
-    yield "🎨 Generating image...", f"✅ Complete! ({width}x{height})"
+    try:
+        # Use provided seed or generate a random one if None
+        actual_seed = seed if seed is not None else int(torch.randint(0, 2**63, (1,)).item())
+        generator = torch.Generator(device=effective_device).manual_seed(actual_seed)
+        result = pipe(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            width=int(width),
+            height=int(height),
+            num_inference_steps=int(steps),
+            guidance_scale=float(cfg),
+            generator=generator,
+        )
 
+        image = result.images[0]
+        yield image, f"✅ Complete! ({int(width)}x{int(height)})"
 
-def set_pipeline(pipe):
-    """Set the global pipeline instance."""
-    global global_pipe
-    global_pipe = pipe
+    except Exception as e:
+        import traceback
+        error_msg = f"❌ Generation failed: {str(e)}"
+        print(error_msg)
+        print(traceback.format_exc())
+        yield None, error_msg

src/pipeline.py

@@ -2,55 +2,16 @@
 
 from pathlib import Path
 
-import torch
 from diffusers import (
     StableDiffusionXLPipeline,
     AutoencoderKL,
     DPMSolverSDEScheduler,
 )
 
-from .config import device, dtype, pipe as global_pipe, CACHE_DIR, device_description, is_running_on_spaces
-
-
-def _make_asymmetric_forward(module, pad_h: int, pad_w: int, tile_x: bool, tile_y: bool):
-    """Create patched forward for seamless tiling on Conv2d layers."""
-    original_forward = module._conv_forward
-
-    def patched_conv_forward(input, weight, bias):
-        if tile_x and tile_y:
-            input = torch.nn.functional.pad(input, (pad_w, pad_w, pad_h, pad_h), mode="circular")
-        elif tile_x:
-            input = torch.nn.functional.pad(input, (pad_w, pad_w, 0, 0), mode="circular")
-            input = torch.nn.functional.pad(input, (0, 0, pad_h, pad_h), mode="constant", value=0)
-        elif tile_y:
-            input = torch.nn.functional.pad(input, (0, 0, pad_h, pad_h), mode="circular")
-            input = torch.nn.functional.pad(input, (pad_w, pad_w, 0, 0), mode="constant", value=0)
-        else:
-            return original_forward(input, weight, bias)
-
-        return torch.nn.functional.conv2d(
-            input, weight, bias, module.stride, (0, 0), module.dilation, module.groups
-        )
-
-    return patched_conv_forward
-
-
-def enable_seamless_tiling(model, tile_x: bool = True, tile_y: bool = False):
-    """
-    Enable seamless tiling on a model's Conv2d layers.
-
-    Args:
-        model: PyTorch model with Conv2d layers (e.g., pipe.unet, pipe.vae.decoder)
-        tile_x: Enable tiling along x-axis
-        tile_y: Enable tiling along y-axis
-    """
-    for module in model.modules():
-        if isinstance(module, torch.nn.Conv2d):
-            pad_h = module.padding[0]
-            pad_w = module.padding[1]
-            if pad_h == 0 and pad_w == 0:
-                continue
-            module._conv_forward = _make_asymmetric_forward(module, pad_h, pad_w, tile_x, tile_y)
+from . import config
+from .config import device, dtype, CACHE_DIR, device_description, is_running_on_spaces, set_download_cancelled
+from .downloader import get_safe_filename_from_url, download_file_with_progress
+from .tiling import enable_seamless_tiling
 
 
 def load_pipeline(
@@ -70,17 +31,18 @@ def load_pipeline(
         lora_strengths_str: Comma-separated strength values for each LoRA
         progress: Optional gr.Progress() object for UI updates
 
+    Yields:
+        Tuple of (status_message, progress_text) at each loading stage.
+
     Returns:
-        Tuple of (final_status_message, progress_text)
+        Final yielded tuple of (final_status_message, progress_text)
     """
-    global global_pipe
+    # Clear any previously loaded pipeline so the UI reflects loading state
+    config.set_pipe(None)
 
     try:
         set_download_cancelled(False)
 
-        # Import gr here to update button state if needed
-        import gradio as gr
-
         print("=" * 60)
         print("🔄 Loading SDXL Pipeline...")
         print("=" * 60)
@@ -93,8 +55,7 @@ def load_pipeline(
 
         # Validate cache file before using it
         if checkpoint_cached:
-            from src.config import validate_cache_file
-            is_valid, msg = validate_cache_file(checkpoint_path)
+            is_valid, msg = config.validate_cache_file(checkpoint_path)
             if not is_valid:
                 print(f"  ⚠️ Cache invalid: {msg}")
                 checkpoint_path.unlink(missing_ok=True)
@@ -107,8 +68,7 @@ def load_pipeline(
 
         # Validate VAE cache file before using it
         if vae_cached:
-            from src.config import validate_cache_file
-            is_valid, msg = validate_cache_file(vae_path)
+            is_valid, msg = config.validate_cache_file(vae_path)
             if not is_valid:
                 print(f"  ⚠️ VAE Cache invalid: {msg}")
                 vae_path.unlink(missing_ok=True)
@@ -124,7 +84,7 @@ def load_pipeline(
         else:
             status_msg = f"✅ Using cached {checkpoint_path.name}"
             print(f"  ✅ Using cached: {checkpoint_path.name}")
-        
+
         yield status_msg, "Starting download..."
 
         if not checkpoint_cached:
@@ -136,10 +96,10 @@ def load_pipeline(
             if vae_path:
                 status_msg = f"📥 Downloading {vae_path.name}..." if not vae_cached else f"✅ Using cached {vae_path.name}"
                 print(f"  📥 VAE: {vae_path.name}" if not vae_cached else f"  ✅ VAE (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:
@@ -158,7 +118,7 @@ def load_pipeline(
         # Load base pipeline (yield progress during this heavy operation)
         print("  ⚙️ Loading SDXL pipeline from single file...")
         yield "⚙️ Loading SDXL pipeline...", "Loading model weights into memory..."
-        
+
         if progress:
             progress(0.3, desc="Loading text encoders...")
 
@@ -166,38 +126,35 @@ def load_pipeline(
         load_kwargs = {
             "torch_dtype": dtype,
             "use_safetensors": True,
-            "safety_checker": None,
         }
 
         if is_running_on_spaces() and device == "cpu":
             print("  ℹ️ CPU mode detected: enabling device_map='auto' for better RAM management")
             load_kwargs["device_map"] = "auto"
-        else:
-            # For GPU, we'll move to device after loading
-            load_kwargs["variant"] = "fp16" if dtype == torch.float16 else None
 
-        global_pipe = StableDiffusionXLPipeline.from_single_file(
+        # Use a local variable for the pipeline being built — only stored globally on success.
+        _pipe = StableDiffusionXLPipeline.from_single_file(
             str(checkpoint_path),
             **load_kwargs,
         )
         print("  ✅ Text encoders loaded")
-        
+
         if progress:
             progress(0.5, desc="Loading UNet...")
 
         print("  ✅ UNet loaded")
-        
+
         # Move to device (unless using device_map='auto' which handles this automatically)
         if not is_running_on_spaces() or device != "cpu":
             print(f"  ⚙️ Moving pipeline to device: {device_description}...")
-            global_pipe = global_pipe.to(device=device, dtype=dtype)
-        
+            _pipe = _pipe.to(device=device, dtype=dtype)
+
         yield "⚙️ Pipeline loaded, setting up components...", f"Using device: {device_description}"
 
         # Load VAE into pipeline if provided
         if vae is not None:
             print("  ⚙️ Setting custom VAE...")
-            global_pipe.vae = vae.to(device=device, dtype=dtype)
+            _pipe.vae = vae.to(device=device, dtype=dtype)
             yield "⚙️ Pipeline loaded, setting up components...", f"VAE loaded: {vae_path.name}"
 
         # Parse LoRA URLs & ensure strengths list matches
@@ -214,35 +171,34 @@ def load_pipeline(
         # Load and fuse each LoRA sequentially (only if URLs exist)
         if lora_urls:
             print(f"  ⚙️ Moving pipeline to device: {device_description}...")
-            global_pipe = global_pipe.to(device=device, dtype=dtype)
+            _pipe = _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, suffix="_lora")
                 lora_path = CACHE_DIR / lora_filename
                 lora_cached = lora_path.exists() and lora_path.stat().st_size > 0
-                
+
                 # Validate LoRA cache file before using it
                 if lora_cached:
-                    from src.config import validate_cache_file
-                    is_valid, msg = validate_cache_file(lora_path)
+                    is_valid, msg = config.validate_cache_file(lora_path)
                     if not is_valid:
                         print(f"  ⚠️ LoRA Cache invalid: {msg}")
                         lora_path.unlink(missing_ok=True)
                         lora_cached = False
-                
+
                 if not lora_cached:
                     print(f"  📥 LoRA {i+1}/{len(lora_urls)}: Downloading {lora_path.name}...")
                     status_msg = f"📥 Downloading LoRA {i+1}/{len(lora_urls)}: {lora_path.name}..."
                 else:
                     print(f"  ✅ LoRA {i+1}/{len(lora_urls)}: Using cached {lora_path.name}")
                     status_msg = f"✅ Using cached LoRA {i+1}/{len(lora_urls)}: {lora_path.name}"
-                
+
                 yield (
                     status_msg,
                     f"Downloading LoRA {i+1}/{len(lora_urls)} ({lora_path.name})..." if not lora_cached
                     else f"Using cached LoRA {i+1}/{len(lora_urls)} ({lora_path.name})"
                 )
-                
+
                 if not lora_cached:
                     download_file_with_progress(lora_url, lora_path)
 
@@ -250,16 +206,16 @@ def load_pipeline(
                 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)
+                _pipe.load_lora_weights(str(lora_path), adapter_name=adapter_name)
                 print(f"  ⚙️ Fusing LoRA {i+1} with strength={strength}...")
-                global_pipe.fuse_lora(adapter_names=[adapter_name], lora_scale=strength)
-                global_pipe.unload_lora_weights()
+                _pipe.fuse_lora(adapter_names=[adapter_name], lora_scale=strength)
+                _pipe.unload_lora_weights()
         else:
             # Move pipeline to device even without LoRAs
             print(f"  ⚙️ Moving pipeline to device: {device_description}...")
-            global_pipe = global_pipe.to(device=device, dtype=dtype)
+            _pipe = _pipe.to(device=device, dtype=dtype)
 
         # Set scheduler and finalize (do this once at the end)
         print("  ⚙️ Configuring scheduler...")
@@ -268,22 +224,26 @@ def load_pipeline(
         if progress:
             progress(0.95, desc="Finalizing...")
 
-        global_pipe.scheduler = DPMSolverSDEScheduler.from_config(
-            global_pipe.scheduler.config,
+        _pipe.scheduler = DPMSolverSDEScheduler.from_config(
+            _pipe.scheduler.config,
             algorithm_type="sde-dpmsolver++",
             use_karras_sigmas=False,
         )
 
+        # ✅ Only publish the pipeline globally AFTER all steps succeed
+        config.set_pipe(_pipe)
+
         print("  ✅ Pipeline ready!")
         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:
         set_download_cancelled(False)
+        config.set_pipe(None)
         print("\n⚠️ Download cancelled by user")
         return ("⚠️ Download cancelled by user", "Cancelled")
     except Exception as e:
         import traceback
+        config.set_pipe(None)
         error_msg = f"❌ Error loading pipeline: {str(e)}"
         print(f"\n{error_msg}")
         print(traceback.format_exc())
@@ -297,4 +257,4 @@ def cancel_download():
 
 def get_pipeline() -> StableDiffusionXLPipeline | None:
     """Get the currently loaded pipeline."""
-    return global_pipe
+    return config.get_pipe()

src/tiling.py

@@ -0,0 +1,52 @@
+"""Seamless tiling utilities for SDXL Model Merger."""
+
+import torch
+
+
+def _make_asymmetric_forward(module, pad_h: int, pad_w: int, tile_x: bool, tile_y: bool):
+    """Create patched forward for seamless tiling on Conv2d layers."""
+    original_forward = module._conv_forward
+
+    def patched_conv_forward(input, weight, bias):
+        if tile_x and tile_y:
+            # Circular padding on both axes
+            input = torch.nn.functional.pad(input, (pad_w, pad_w, pad_h, pad_h), mode="circular")
+        elif tile_x:
+            # Circular padding only on left/right edges, constant (zero) on top/bottom
+            # Asymmetric padding for 360° panorama tiling
+            input = torch.nn.functional.pad(input, (pad_w, pad_w, 0, 0), mode="circular")
+            input = torch.nn.functional.pad(input, (0, 0, pad_h, pad_h), mode="constant", value=0)
+        elif tile_y:
+            # Circular padding only on top/bottom edges, constant (zero) on left/right
+            input = torch.nn.functional.pad(input, (0, 0, pad_h, pad_h), mode="circular")
+            input = torch.nn.functional.pad(input, (pad_w, pad_w, 0, 0), mode="constant", value=0)
+        else:
+            return original_forward(input, weight, bias)
+
+        return torch.nn.functional.conv2d(
+            input, weight, bias, module.stride, (0, 0), module.dilation, module.groups
+        )
+
+    return patched_conv_forward
+
+
+def enable_seamless_tiling(model, tile_x: bool = True, tile_y: bool = False):
+    """
+    Enable seamless tiling on a model's Conv2d layers.
+
+    Args:
+        model: PyTorch model with Conv2d layers (e.g., pipe.unet, pipe.vae.decoder)
+        tile_x: Enable tiling along x-axis
+        tile_y: Enable tiling along y-axis
+    """
+    for module in model.modules():
+        if isinstance(module, torch.nn.Conv2d):
+            pad_h = module.padding[0]
+            pad_w = module.padding[1]
+            if pad_h == 0 and pad_w == 0:
+                continue
+            current = getattr(module, "_tiling_config", None)
+            if current == (tile_x, tile_y):
+                continue  # already patched with same config
+            module._tiling_config = (tile_x, tile_y)
+            module._conv_forward = _make_asymmetric_forward(module, pad_h, pad_w, tile_x, tile_y)

src/ui/generator_tab.py

@@ -8,7 +8,7 @@ from ..generator import generate_image
 
 def create_generator_tab():
     """Create the image generation tab with all input controls."""
-    
+
     with gr.Accordion("🎨 2. Generate Image", open=True, elem_classes=["feature-card"]):
         # Prompts section
         with gr.Row():
@@ -19,19 +19,19 @@ def create_generator_tab():
                     lines=3,
                     placeholder="Describe the image you want to generate..."
                 )
-                
+
                 cfg = gr.Slider(
                     minimum=1.0, maximum=20.0, value=7.5, step=0.5,
                     label="CFG Scale",
                     info="Higher values make outputs match prompt more strictly"
                 )
-                
+
                 height = gr.Number(
                     value=1024, precision=0,
                     label="Height (pixels)",
                     info="Output image height"
                 )
-            
+
             with gr.Column(scale=1):
                 negative_prompt = gr.Textbox(
                     label="Negative Prompt",
@@ -39,28 +39,28 @@ def create_generator_tab():
                     lines=3,
                     placeholder="Elements to avoid in generation..."
                 )
-                
+
                 steps = gr.Slider(
                     minimum=1, maximum=100, value=25, step=1,
                     label="Inference Steps",
                     info="More steps = better quality but slower"
                 )
-                
+
                 width = gr.Number(
                     value=2048, precision=0,
                     label="Width (pixels)",
                     info="Output image width"
                 )
-        
+
         # Tiling options
         with gr.Row():
             tile_x = gr.Checkbox(True, label="X-axis Seamless Tiling")
             tile_y = gr.Checkbox(False, label="Y-axis Seamless Tiling")
-        
+
         # Generate button and outputs
         with gr.Row():
             gen_btn = gr.Button("✨ Generate Image", variant="secondary", size="lg")
-        
+
         with gr.Row():
             image_output = gr.Image(
                 label="Result",
@@ -68,12 +68,18 @@ def create_generator_tab():
                 show_label=True
             )
             with gr.Column():
-                gen_status = gr.Textbox(
+                gen_status = gr.HTML(
                     label="Generation Status",
-                    placeholder="Ready to generate..."
+                    value='<div class="status-success">✅ Ready to generate</div>',
                 )
-                
-                # Quick tips
+
+                gen_progress = gr.Textbox(
+                    label="Generation Progress",
+                    placeholder="Ready to generate...",
+                    show_label=True,
+                    visible=False
+                )
+
                 gr.HTML("""
                     <div style="margin-top: 16px; padding: 12px; background: #f3f4f6; border-radius: 8px;">
                         <strong>💡 Tips:</strong>
@@ -84,21 +90,52 @@ def create_generator_tab():
                         </ul>
                     </div>
                 """)
-    
+
     return (
         prompt, negative_prompt, cfg, steps, height, width,
-        tile_x, tile_y, gen_btn, image_output, gen_status
+        tile_x, tile_y, gen_btn, image_output, gen_status, gen_progress
     )
 
 
 def setup_generator_events(
     prompt, negative_prompt, cfg, steps, height, width,
-    tile_x, tile_y, gen_btn, image_output, gen_status
+    tile_x, tile_y, gen_btn, image_output, gen_status, gen_progress
 ):
     """Setup event handlers for the generator tab."""
-    
+
+    def on_generate_start():
+        return (
+            '<div class="status-warning">⏳ Generating image...</div>',
+            "Starting generation...",
+            gr.update(interactive=False),
+        )
+
+    def on_generate_complete(img, msg):
+        """Read both image and last progress message to determine success/failure."""
+        if img is None:
+            return (
+                f'<div class="status-error">{msg}</div>',
+                "",
+                gr.update(interactive=True),
+                gr.update(),
+            )
+        return (
+            '<div class="status-success">✅ Generation complete!</div>',
+            "Done",
+            gr.update(interactive=True),
+            gr.update(value=img),
+        )
+
     gen_btn.click(
+        fn=on_generate_start,
+        inputs=[],
+        outputs=[gen_status, gen_progress, gen_btn],
+    ).then(
         fn=generate_image,
         inputs=[prompt, negative_prompt, cfg, steps, height, width, tile_x, tile_y],
-        outputs=[image_output, gen_status],
+        outputs=[image_output, gen_progress],
+    ).then(
+        fn=on_generate_complete,
+        inputs=[image_output, gen_progress],
+        outputs=[gen_status, gen_progress, gen_btn, image_output],
     )