feat: dynamic download paths

Author: Yumeo0

api/civitai.py

@@ -252,4 +252,65 @@ def search_models_meili(self, query: str, types: Optional[List[str]] = None,
         except json.JSONDecodeError as json_err:
             print(f"Civitai Meili Search Error: Failed to decode JSON response from {meili_url}: {json_err}")
             response_text = response.text[:200] if hasattr(response, 'text') else "N/A"
-            return {"error": "Invalid JSON response from Meili", "details": response_text, "status_code": response.status_code if hasattr(response, 'status_code') else None}
+            return {"error": "Invalid JSON response from Meili", "details": response_text, "status_code": response.status_code if hasattr(response, 'status_code') else None}
+
+    def get_model_details_trpc(self, model_id: int) -> Optional[Dict[str, Any]]:
+        """Gets detailed model information including categories from the TRPC endpoint."""
+        trpc_url = f"https://civitai.com/api/trpc/model.getById"
+        params = {
+            "input": json.dumps({"json": {"id": model_id, "authed": True}})
+        }
+        
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        try:
+            response = requests.get(trpc_url, params=params, headers=headers, timeout=30)
+            response.raise_for_status()
+            
+            data = response.json()
+            
+            # Extract the model data from TRPC response structure
+            if isinstance(data, dict) and "result" in data and "data" in data["result"] and "json" in data["result"]["data"]:
+                return data["result"]["data"]["json"]
+            else:
+                print(f"Warning: Unexpected TRPC response structure: {data}")
+                return None
+                
+        except requests.exceptions.HTTPError as http_err:
+            error_detail = None
+            status_code = http_err.response.status_code
+            try:
+                error_detail = http_err.response.json()
+            except json.JSONDecodeError:
+                error_detail = http_err.response.text[:200]
+            print(f"Civitai TRPC HTTP Error ({trpc_url}): Status {status_code}, Response: {error_detail}")
+            return {"error": f"TRPC HTTP Error: {status_code}", "details": error_detail, "status_code": status_code}
+
+        except requests.exceptions.RequestException as req_err:
+            print(f"Civitai TRPC Request Error ({trpc_url}): {req_err}")
+            return {"error": str(req_err), "details": None, "status_code": None}
+
+        except json.JSONDecodeError as json_err:
+            print(f"Civitai TRPC Error: Failed to decode JSON response from {trpc_url}: {json_err}")
+            response_text = response.text[:200] if hasattr(response, 'text') else "N/A"
+            return {"error": "Invalid JSON response from TRPC", "details": response_text, "status_code": response.status_code if hasattr(response, 'status_code') else None}
+
+    def extract_model_category(self, trpc_data: Dict[str, Any]) -> Optional[str]:
+        """Extracts the model category from TRPC model data."""
+        if not isinstance(trpc_data, dict) or "tagsOnModels" not in trpc_data:
+            return None
+            
+        tags_on_models = trpc_data.get("tagsOnModels", [])
+        if not isinstance(tags_on_models, list):
+            return None
+            
+        # Find the tag with isCategory=True
+        for tag_entry in tags_on_models:
+            if isinstance(tag_entry, dict) and "tag" in tag_entry:
+                tag = tag_entry["tag"]
+                if isinstance(tag, dict) and tag.get("isCategory") is True:
+                    return tag.get("name")
+        
+        return None

server/routes/DownloadModel.py

@@ -8,7 +8,7 @@
 from aiohttp import web
 
 import server # ComfyUI server instance
-from ..utils import get_request_json
+from ..utils import get_request_json, process_custom_download_path
 from ...downloader.manager import manager as download_manager
 from ...api.civitai import CivitaiAPI
 from ...utils.helpers import get_model_dir, parse_civitai_input, sanitize_filename, select_primary_file
@@ -34,7 +34,7 @@ async def route_download_model(request):
         req_version_id = data.get("model_version_id") # Optional explicit version ID
         explicit_save_root = (data.get("save_root") or "").strip()
         custom_filename_input = data.get("custom_filename", "").strip()
-        selected_subdir = (data.get("subdir") or "").strip()
+        custom_download_path = data.get("custom_download_path", "").strip()
         # Optional file selection overrides
         req_file_id = data.get("file_id")
         req_file_name_contains = data.get("file_name_contains", "").strip()
@@ -218,6 +218,18 @@ def name_matches(f):
 
         file_id = primary_file.get("id") # May not be present, but useful for logging/metadata
 
+        # Fetch model category from TRPC if needed for custom path processing
+        model_category = None
+        if custom_download_path:
+            try:
+                trpc_data = api.get_model_details_trpc(target_model_id)
+                if trpc_data and (not isinstance(trpc_data, dict) or "error" not in trpc_data):
+                    model_category = api.extract_model_category(trpc_data)
+                    print(f"[Server Download] Extracted model category: {model_category}")
+            except Exception as e:
+                print(f"[Server Download] Warning: Failed to fetch TRPC category data: {e}")
+                # Continue without category data
+
         # *** Get the download URL directly from the file object ***
         download_url = primary_file.get("downloadUrl")
         print(f"[Server Download] Using Download URL: {download_url}")
@@ -229,12 +241,18 @@ def name_matches(f):
         final_filename = sanitize_filename(api_filename)
         sub_path = ""
 
-        # Subdir: only use the selected existing subdir coming from UI
-        if selected_subdir:
-            norm_sub = os.path.normpath(selected_subdir.replace('\\', '/'))
-            parts = [p for p in norm_sub.split('/') if p and p not in ('.', '..')]
-            if parts:
-                sub_path = os.path.join(*[sanitize_filename(p) for p in parts])
+        # Handle custom download path with variable substitution
+        if custom_download_path:
+            processed_path = process_custom_download_path(
+                custom_download_path, 
+                model_info, 
+                version_info, 
+                model_category, 
+                model_type_value
+            )
+            if processed_path:
+                sub_path = processed_path
+                print(f"[Server Download] Using custom download path: {sub_path}")
 
         # Filename: ignore any path separators in custom name; treat as base name only
         if custom_filename_input:
@@ -407,6 +425,7 @@ def _guess_precision_name(fobj):
             "model_url_or_id": model_url_or_id,
             "model_version_id": req_version_id,
             "custom_filename": custom_filename_input,
+            "custom_download_path": custom_download_path,
             "force_redownload": force_redownload,
             # UI Display Info
             "filename": final_filename,

server/routes/GetModelDetails.py

@@ -36,6 +36,16 @@ async def route_get_model_details(request):
         target_model_id = details['target_model_id']
         target_version_id = details['target_version_id']
 
+        # Fetch additional category information from TRPC
+        model_category = None
+        try:
+            trpc_data = api.get_model_details_trpc(target_model_id)
+            if trpc_data and (not isinstance(trpc_data, dict) or "error" not in trpc_data):
+                model_category = api.extract_model_category(trpc_data)
+        except Exception as e:
+            print(f"[GetModelDetails] Warning: Failed to fetch TRPC category data: {e}")
+            # Continue without category data
+
         # --- Extract Data for Frontend Preview ---
         model_name = model_info.get('name')
         creator_username = model_info.get('creator', {}).get('username', 'Unknown Creator')
@@ -171,6 +181,7 @@ def _guess_precision(file_dict):
             "nsfw_level": nsfw_level,
             # Optionally include basic version info like baseModel
             "base_model": version_info.get("baseModel", "N/A"),
+            "model_category": model_category,
             # You could add tags here too if desired: model_info.get('tags', [])
         })
 

server/utils.py

@@ -2,6 +2,8 @@
 # File: server/utils.py
 # ================================================
 import json
+import re
+import os
 from typing import Any, Dict, Optional
 from aiohttp import web
 
@@ -151,4 +153,74 @@ async def get_civitai_model_and_version_details(api: CivitaiAPI, model_url_or_id
         "primary_file": primary_file,              # The file from that version
         "target_model_id": target_model_id,        # Resolved model ID
         "target_version_id": target_version_id,    # Resolved version ID (specific or latest)
-    }
+    }
+
+def process_custom_download_path(custom_path: str, model_info: Dict[str, Any], 
+                                 version_info: Dict[str, Any], model_category: Optional[str] = None,
+                                 model_type: str = "") -> str:
+    """
+    Process a custom download path by substituting variables with actual model data.
+    
+    Args:
+        custom_path: The custom path template with variables like {model}, {base_model}, etc.
+        model_info: Model information from the API
+        version_info: Version information from the API
+        model_category: Model category extracted from TRPC (optional)
+        model_type: The selected model type/folder
+        
+    Returns:
+        Processed path with variables substituted
+    """
+    if not custom_path or not isinstance(custom_path, str):
+        return ""
+    
+    # Sanitize function to clean up names for filesystem use
+    def sanitize_name(name: str) -> str:
+        if not name or not isinstance(name, str):
+            return "unknown"
+        # Remove or replace problematic characters for filesystem
+        # Keep alphanumeric, spaces, hyphens, underscores, periods
+        sanitized = re.sub(r'[<>:"/\\|?*]', '_', name)
+        # Replace multiple spaces/underscores with single underscore
+        sanitized = re.sub(r'[\s_]+', '_', sanitized)
+        # Remove leading/trailing whitespace and underscores
+        sanitized = sanitized.strip('_').strip()
+        # Limit length to avoid filesystem issues
+        return sanitized[:100] if sanitized else "unknown"
+    
+    # Extract data for substitution
+    model_name = sanitize_name(model_info.get('name', 'unknown_model'))
+    base_model = sanitize_name(version_info.get('baseModel', 'unknown_base'))
+    category = sanitize_name(model_category or 'unknown_category')
+    model_type_clean = sanitize_name(model_type)
+    
+    # Variable substitution map
+    variables = {
+        'model_name': model_name,
+        'base_model': base_model,
+        'model_category': category,
+        'model_type': model_type_clean
+    }
+    
+    # Perform substitution
+    processed_path = custom_path
+    for var_name, var_value in variables.items():
+        pattern = '{' + var_name + '}'
+        processed_path = processed_path.replace(pattern, var_value)
+    
+    # Clean up any remaining unreplaced variables (remove empty braces)
+    processed_path = re.sub(r'\{[^}]*\}', '', processed_path)
+    
+    # Clean up path separators and ensure it's a valid relative path
+    processed_path = processed_path.replace('\\', '/')  # Normalize separators
+    processed_path = re.sub(r'/+', '/', processed_path)  # Remove duplicate slashes
+    processed_path = processed_path.strip('/')  # Remove leading/trailing slashes
+    
+    # Ensure the path doesn't try to escape the base directory
+    path_parts = []
+    for part in processed_path.split('/'):
+        part = part.strip()
+        if part and part not in ('.', '..'):
+            path_parts.append(part)
+    
+    return '/'.join(path_parts)

web/js/ui/UI.js

@@ -54,8 +54,7 @@ export class CivitaiDownloaderUI {
         this.downloadModelTypeSelect = this.modal.querySelector('#civitai-model-type');
         this.createModelTypeButton = this.modal.querySelector('#civitai-create-model-type');
         this.customFilenameInput = this.modal.querySelector('#civitai-custom-filename');
-        this.subdirSelect = this.modal.querySelector('#civitai-subdir-select');
-        this.createSubdirButton = this.modal.querySelector('#civitai-create-subdir');
+        this.customDownloadPathInput = this.modal.querySelector('#civitai-custom-download-path');
         this.downloadConnectionsInput = this.modal.querySelector('#civitai-connections');
         this.forceRedownloadCheckbox = this.modal.querySelector('#civitai-force-redownload');
         this.downloadSubmitButton = this.modal.querySelector('#civitai-download-submit');
@@ -88,6 +87,7 @@ export class CivitaiDownloaderUI {
         this.settingsApiKeyInput = this.modal.querySelector('#civitai-settings-api-key');
         this.settingsConnectionsInput = this.modal.querySelector('#civitai-settings-connections');
         this.settingsDefaultTypeSelect = this.modal.querySelector('#civitai-settings-default-type');
+        this.settingsCustomPathInput = this.modal.querySelector('#civitai-settings-custom-path');
         this.settingsAutoOpenCheckbox = this.modal.querySelector('#civitai-settings-auto-open-status');
         this.settingsHideMatureCheckbox = this.modal.querySelector('#civitai-settings-hide-mature');
         this.settingsNsfwThresholdInput = this.modal.querySelector('#civitai-settings-nsfw-threshold');
@@ -120,7 +120,7 @@ export class CivitaiDownloaderUI {
         try {
             const types = await CivitaiDownloaderAPI.getModelTypes();
             if (!types || typeof types !== 'object' || Object.keys(types).length === 0) {
-                 throw new Error("Received invalid model types data format.");
+                throw new Error("Received invalid model types data format.");
             }
             this.modelTypes = types;
             const sortedTypes = Object.entries(this.modelTypes).sort((a, b) => a[1].localeCompare(b[1]));
@@ -133,12 +133,10 @@ export class CivitaiDownloaderUI {
                 const option = document.createElement('option');
                 option.value = key;
                 option.textContent = displayName;
-            this.downloadModelTypeSelect.appendChild(option.cloneNode(true));
-            this.settingsDefaultTypeSelect.appendChild(option.cloneNode(true));
-            this.searchTypeSelect.appendChild(option.cloneNode(true));
-        });
-        // After types are populated, load subdirs for the current selection
-        await this.loadAndPopulateSubdirs(this.downloadModelTypeSelect.value);
+                this.downloadModelTypeSelect.appendChild(option.cloneNode(true));
+                this.settingsDefaultTypeSelect.appendChild(option.cloneNode(true));
+                this.searchTypeSelect.appendChild(option.cloneNode(true));
+            });
         } catch (error) {
             console.error("[Civicomfy] Failed to get or populate model types:", error);
             this.showToast('Failed to load model types', 'error');
@@ -147,38 +145,6 @@ export class CivitaiDownloaderUI {
         }
     }
 
-    async loadAndPopulateSubdirs(modelType) {
-        try {
-            const res = await CivitaiDownloaderAPI.getModelDirs(modelType);
-            const select = this.subdirSelect;
-            if (!select) return;
-            const current = select.value;
-            select.innerHTML = '';
-            const optRoot = document.createElement('option');
-            optRoot.value = '';
-            optRoot.textContent = '(root)';
-            select.appendChild(optRoot);
-            if (res && Array.isArray(res.subdirs)) {
-                // res.subdirs contains '' for root; skip empty since we added (root)
-                res.subdirs.filter(p => p && typeof p === 'string').forEach(rel => {
-                    const opt = document.createElement('option');
-                    opt.value = rel;
-                    opt.textContent = rel;
-                    select.appendChild(opt);
-                });
-            }
-            // Restore selection if still present
-            if (Array.from(select.options).some(o => o.value === current)) {
-                select.value = current;
-            }
-        } catch (e) {
-            console.error('[Civicomfy] Failed to load subdirectories:', e);
-            if (this.subdirSelect) {
-                this.subdirSelect.innerHTML = '<option value="">(root)</option>';
-            }
-        }
-    }
-
     // (loadAndPopulateRoots removed; dynamic types already reflect models/ subfolders)
 
     async populateBaseModels() {
@@ -198,8 +164,8 @@ export class CivitaiDownloaderUI {
                 this.searchBaseModelSelect.appendChild(option);
             });
         } catch (error) {
-             console.error("[Civicomfy] Failed to get or populate base models:", error);
-             this.showToast('Failed to load base models list', 'error');
+            console.error("[Civicomfy] Failed to get or populate base models:", error);
+            this.showToast('Failed to load base models list', 'error');
         }
     }
 
@@ -216,11 +182,14 @@ export class CivitaiDownloaderUI {
 
         if (tabId === 'status') this.updateStatus();
         else if (tabId === 'settings') this.applySettings();
-        else if(tabId === 'download') {
+        else if (tabId === 'download') {
             this.downloadConnectionsInput.value = this.settings.numConnections;
             if (Object.keys(this.modelTypes).length > 0) {
                 this.downloadModelTypeSelect.value = this.settings.defaultModelType;
             }
+            if (this.customDownloadPathInput) {
+                this.customDownloadPathInput.value = this.settings.customDownloadPath || '';
+            }
         }
     }
 
@@ -280,7 +249,7 @@ export class CivitaiDownloaderUI {
     renderDownloadList = (items, container, emptyMessage) => renderDownloadList(this, items, container, emptyMessage);
     renderSearchResults = (items) => renderSearchResults(this, items);
     renderDownloadPreview = (data) => renderDownloadPreview(this, data);
-    
+
     // --- Auto-select model type based on Civitai model type ---
     inferFolderFromCivitaiType(civitaiType) {
         if (!civitaiType || typeof civitaiType !== 'string') return null;
@@ -358,9 +327,6 @@ export class CivitaiDownloaderUI {
             if (!folder) return;
             if (this.downloadModelTypeSelect && this.downloadModelTypeSelect.value !== folder) {
                 this.downloadModelTypeSelect.value = folder;
-                await this.loadAndPopulateSubdirs(folder);
-                // Reset subdir to root after auto-switch
-                if (this.subdirSelect) this.subdirSelect.value = '';
             }
         } catch (e) {
             console.warn('[Civicomfy] Auto-select model type failed:', e);
@@ -390,7 +356,7 @@ export class CivitaiDownloaderUI {
 
         const fragment = document.createDocumentFragment();
         fragment.appendChild(createButton('&laquo; Prev', currentPage - 1, currentPage === 1));
-        
+
         let startPage = Math.max(1, currentPage - 2);
         let endPage = Math.min(totalPages, currentPage + 2);
 
@@ -403,7 +369,7 @@ export class CivitaiDownloaderUI {
 
         if (endPage < totalPages - 1) fragment.appendChild(document.createElement('span')).textContent = '...';
         if (endPage < totalPages) fragment.appendChild(createButton(totalPages, totalPages));
-        
+
         fragment.appendChild(createButton('Next &raquo;', currentPage + 1, currentPage === totalPages));
 
         const info = document.createElement('div');