Update app.py

app.py

@@ -8,7 +8,7 @@ from collections import OrderedDict
 import re
 import json
 import gdown
-#import requests # Removed
+import requests  # Re-added for URL handling
 import subprocess
 from urllib.parse import urlparse, unquote
 from pathlib import Path
@@ -20,7 +20,7 @@ import shutil
 import hashlib
 from datetime import datetime
 from typing import Dict, List, Optional
-from huggingface_hub import login, HfApi, hf_hub_download, get_from_cache
+from huggingface_hub import login, HfApi, hf_hub_download, get_from_cache  # Corrected import
 from huggingface_hub.utils import validate_repo_id, HFValidationError
 from huggingface_hub.errors import HfHubHTTPError
 from huggingface_hub.constants import HUGGINGFACE_HUB_CACHE  # Import HUGGINGFACE_HUB_CACHE
@@ -80,16 +80,52 @@ def create_model_repo(api, user, orgs_name, model_name, make_private=False):
 
 # ---------------------- MODEL LOADING AND CONVERSION ----------------------
 def download_model(model_path_or_url):
-    """Downloads a model from a Hugging Face Hub repository."""
+    """Downloads a model, handling URLs, HF repos, and local paths, caching appropriately."""
     try:
-        # Check if it's a valid Hugging Face repo ID (and potentially a file within)
+        # 1. Check if it's a valid Hugging Face repo ID (and potentially a file within)
         try:
             validate_repo_id(model_path_or_url)
             # It's a valid repo ID; use hf_hub_download (it handles caching)
             local_path = hf_hub_download(repo_id=model_path_or_url)
             return local_path
         except HFValidationError:
-            # Might be a repo ID + filename
+            pass  # Not a simple repo ID. Might be repo ID + filename, or a URL.
+
+        # 2. Check if it's a URL
+        if model_path_or_url.startswith("http://") or model_path_or_url.startswith(
+            "https://"
+        ):
+            # Check if it's already in the cache
+            cache_path = get_from_cache(model_path_or_url)  # Use get_from_cache
+            if cache_path is not None:
+                return cache_path
+
+            # It's a URL and not in cache: download manually and put into HF cache
+            response = requests.get(model_path_or_url, stream=True)
+            response.raise_for_status()  # Raise HTTPError for bad requests (4xx or 5xx)
+
+            # Get filename from URL, or use a hash if we can't determine it
+            parsed_url = urlparse(model_path_or_url)
+            filename = os.path.basename(unquote(parsed_url.path))
+            if not filename:
+                filename = hashlib.sha256(model_path_or_url.encode()).hexdigest()
+
+            # Construct the cache path (using HF_HUB_CACHE + "downloads")
+            cache_dir = os.path.join(HUGGINGFACE_HUB_CACHE, "downloads")
+            os.makedirs(cache_dir, exist_ok=True)  # Ensure cache directory exists
+            local_path = os.path.join(cache_dir, filename)
+
+            with open(local_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            return local_path
+
+        # 3. Check if it's a local file
+        elif os.path.isfile(model_path_or_url):
+            return model_path_or_url
+
+        # 4. Handle Hugging Face repo with a specific file
+        else:
             try:
                 parts = model_path_or_url.split("/", 1)
                 if len(parts) == 2:
@@ -98,12 +134,13 @@ def download_model(model_path_or_url):
                     local_path = hf_hub_download(repo_id=repo_id, filename=filename)
                     return local_path
                 else:
-                    raise ValueError("Invalid Hugging Face repository format.")
+                    raise ValueError("Invalid input format.")
+
             except HFValidationError:
-                raise ValueError(f"Invalid Hugging Face repository ID or path: {model_path_or_url}")
+                raise ValueError(f"Invalid model path or URL: {model_path_or_url}")
 
     except Exception as e:
-        raise ValueError(f"Error downloading model: {e}")
+        raise ValueError(f"Error downloading or accessing model: {e}")
 
 
 def load_sdxl_checkpoint(checkpoint_path):
@@ -269,8 +306,9 @@ with gr.Blocks(css=css) as demo:
     Convert SDXL checkpoints to Diffusers format (FP16, CPU-only).
 
     ### 📥 Input Sources Supported:
-    - Only Hugging Face model repositories (e.g., 'my-org/my-model' or 'my-org/my-model/file.safetensors')
-    - Non HF repository Gradio edition will eventually pop up on the Ktiseos Nyx github.
+    - Local model files (.safetensors, .ckpt)
+    - Direct URLs to model files
+    - Hugging Face model repositories (e.g., 'my-org/my-model' or 'my-org/my-model/file.safetensors')
 
     ### ℹ️ Important Notes:
     - This tool runs on **CPU**, conversion might be slower than on GPU.
@@ -281,7 +319,6 @@ with gr.Blocks(css=css) as demo:
     - This space is configured for **FP16** precision to reduce memory usage.
     - Close other applications during conversion.
     - For large models, ensure you have at least 16GB of RAM.
-    
 
     ### 💻 Source Code:
     - [GitHub Repository](https://github.com/Ktiseos-Nyx/Gradio-SDXL-Diffusers)
@@ -293,8 +330,8 @@ with gr.Blocks(css=css) as demo:
 
     with gr.Column(elem_id="main-container"):  # Use a Column for layout
         model_to_load = gr.Textbox(
-            label="SDXL Checkpoint (HF Repo)",  # More specific label
-            placeholder="Hugging Face Repo ID (e.g., my-org/my-model or my-org/my-model/file.safetensors)",
+            label="SDXL Checkpoint (Path, URL, or HF Repo)",
+            placeholder="Path, URL, or Hugging Face Repo ID (e.g., my-org/my-model or my-org/my-model/file.safetensors)",
         )
         reference_model = gr.Textbox(
             label="Reference Diffusers Model (Optional)",