Fix nested HF LoRA weight paths for custom imports

Parse user/repo/sub/.../file.safetensors into hub repo + nested weight path; allow weight field subfolder/file and user/repo/sub + bare file.

Co-Authored-By: Oz <oz-agent@warp.dev>

app.py

@@ -912,12 +912,14 @@ with gr.Blocks() as demo:
                     with gr.Row():
                         lora_repo_id = gr.Textbox(
                             label="HF repo ID or local path",
-                            placeholder="username/repo-name  or  /loras-flux/my.safetensors",
+                            placeholder="user/repo  or  user/repo/sub/model.safetensors  or  /loras-flux/my.safetensors",
+                            info="Nested HF paths OK: user/repo/folder/model.safetensors",
                         )
                     with gr.Row():
                         lora_weight_name = gr.Textbox(
-                            label="Weight filename (optional if path is a .safetensors file)",
-                            placeholder="pytorch_lora_weights.safetensors",
+                            label="Weight path inside repo (optional)",
+                            placeholder="subfolder/model.safetensors",
+                            info="Use for nested files if not included in the repo field.",
                         )
                         lora_adapter_name = gr.Textbox(label="Adapter name (optional)", placeholder="my-lora")
                     with gr.Row():

lora_registry.py

@@ -832,6 +832,57 @@ def _looks_like_local_path(value: str) -> bool:
     return bool(value) and value.startswith("/")
 
 
+def _is_weight_filename(name: str | None) -> bool:
+    if not name:
+        return False
+    lower = str(name).strip().lower()
+    return any(lower.endswith(ext) for ext in _WEIGHT_EXTS)
+
+
+def _split_hf_repo_and_weight(repo_id: str, weight_name: str | None) -> tuple[str, str | None]:
+    """Split owner/repo[/nested/weight.safetensors] into hub repo id + weight path.
+
+    Supports nested weights inside the repo, e.g.:
+      user/repo/sub/dir/model.safetensors  -> repo=user/repo, weight=sub/dir/model.safetensors
+      user/repo + weight=sub/dir/model.safetensors (unchanged)
+    """
+    repo = (repo_id or "").strip().strip("/")
+    weight = weight_name.strip() if weight_name and str(weight_name).strip() else None
+
+    # If weight already given: hub repo is owner/name; optional extra path
+    # segments are a subfolder prefix (user/repo/sub + file.safetensors).
+    if weight:
+        weight = weight.lstrip("/")
+        parts = [p for p in repo.split("/") if p]
+        if len(parts) >= 2:
+            hub = f"{parts[0]}/{parts[1]}"
+            extra = parts[2:]
+            # user/repo/subfolder + model.safetensors -> subfolder/model.safetensors
+            if extra and not _is_weight_filename(extra[-1]):
+                prefix = "/".join(extra)
+                if not (weight == prefix or weight.startswith(prefix + "/")):
+                    weight = f"{prefix}/{weight}"
+            return hub, weight
+        return repo, weight
+
+    parts = [p for p in repo.split("/") if p]
+    if len(parts) <= 2:
+        return repo, None
+
+    # owner/repo/<rest...>
+    owner, name, *rest = parts
+    hub_repo = f"{owner}/{name}"
+    rest_path = "/".join(rest)
+
+    # user/repo/file.safetensors  OR  user/repo/sub/file.safetensors
+    if _is_weight_filename(rest[-1]):
+        return hub_repo, rest_path
+
+    # user/repo/subfolder  (prefix inside repo; weight still unknown)
+    # Keep as repo + None so auto-detect can filter siblings under this prefix.
+    return hub_repo, None if not rest_path else f"{rest_path}/"  # trailing slash = prefix marker
+
+
 def _resolve_local_lora(path_str: str, weight_name: str | None):
     path = Path(os.path.expanduser(path_str)).resolve()
     requested = weight_name.strip() if weight_name and weight_name.strip() else None
@@ -839,69 +890,144 @@ def _resolve_local_lora(path_str: str, weight_name: str | None):
     if path.is_file():
         if path.suffix.lower() not in _WEIGHT_EXTS:
             raise ValueError(f"Not a LoRA weight file: {path.name}")
+        # Keep nested filename only for local load_lora_weights(dir, weight_name=file)
         return str(path.parent), path.name, path.stem
 
     if not path.is_dir():
         raise FileNotFoundError(f"Local path not found: {path}")
 
     if requested:
-        candidate = path / requested
+        # Allow nested relative weight paths: sub/dir/model.safetensors
+        candidate = (path / requested).resolve()
+        try:
+            candidate.relative_to(path)
+        except ValueError as e:
+            raise FileNotFoundError(
+                f"Weight path escapes directory {path}: {requested}"
+            ) from e
         if not candidate.is_file():
             available = sorted(
-                p.name for p in path.iterdir()
+                str(p.relative_to(path))
+                for p in path.rglob("*")
                 if p.is_file() and p.suffix.lower() in _WEIGHT_EXTS
-            )
+            )[:20]
             raise FileNotFoundError(
-                f"'{requested}' not in {path}. Available: {', '.join(available) or 'None'}"
+                f"'{requested}' not under {path}. Available: {', '.join(available) or 'None'}"
             )
-        return str(path), requested, Path(requested).stem
+        # diffusers local: repo=dir containing file tree root we pass, weights=relpath
+        rel = str(candidate.relative_to(path)).replace("\\", "/")
+        return str(path), rel, Path(rel).stem
 
     for name in _DEFAULT_WEIGHT_CANDIDATES:
         if (path / name).is_file():
             return str(path), name, path.name
 
-    available = sorted(
+    # Prefer top-level weights; fall back to a single nested weight if unique.
+    top = sorted(
         p.name for p in path.iterdir()
         if p.is_file() and p.suffix.lower() in _WEIGHT_EXTS
     )
-    if len(available) == 1:
-        return str(path), available[0], Path(available[0]).stem
-    if not available:
+    if len(top) == 1:
+        return str(path), top[0], Path(top[0]).stem
+    if top:
+        raise FileNotFoundError(
+            f"Multiple weights in {path}; set Weight filename. Available: {', '.join(top)}"
+        )
+
+    nested = sorted(
+        str(p.relative_to(path)).replace("\\", "/")
+        for p in path.rglob("*")
+        if p.is_file() and p.suffix.lower() in _WEIGHT_EXTS
+    )
+    if len(nested) == 1:
+        return str(path), nested[0], Path(nested[0]).stem
+    if not nested:
         raise FileNotFoundError(f"No .safetensors/.bin weights found in {path}")
     raise FileNotFoundError(
-        f"Multiple weights in {path}; set Weight filename. Available: {', '.join(available)}"
+        f"Multiple nested weights in {path}; set Weight path. Available: {', '.join(nested[:20])}"
     )
 
 
 def _resolve_hf_lora(repo_id: str, weight_name: str | None):
     from huggingface_hub import model_info
 
-    info = model_info(repo_id)
-    actual_weight = weight_name.strip() if weight_name and weight_name.strip() else None
+    hub_repo, weight_or_prefix = _split_hf_repo_and_weight(repo_id, weight_name)
+    # Trailing slash marks "directory prefix inside repo" from user/repo/subfolder
+    prefix = None
+    actual_weight = weight_or_prefix
+    if actual_weight and actual_weight.endswith("/") and not _is_weight_filename(actual_weight):
+        prefix = actual_weight.lstrip("/")
+        actual_weight = None
+    elif actual_weight:
+        actual_weight = actual_weight.lstrip("/")
+
+    info = model_info(hub_repo)
+    siblings = list(info.siblings or [])
+
+    def _weight_siblings(pref: str | None = None):
+        out = []
+        for f in siblings:
+            name = getattr(f, "filename", None) or ""
+            if not name.endswith(_WEIGHT_EXTS):
+                continue
+            if pref and not name.startswith(pref):
+                continue
+            out.append(name)
+        return out
+
     if not actual_weight:
+        # Auto-pick under optional subfolder prefix.
+        search_prefix = prefix or ""
         for name in _DEFAULT_WEIGHT_CANDIDATES:
-            if any(f.filename == name for f in info.siblings):
-                actual_weight = name
+            candidate = f"{search_prefix}{name}" if search_prefix else name
+            if any(getattr(f, "filename", None) == candidate for f in siblings):
+                actual_weight = candidate
                 break
-    if not actual_weight:
-        available = [
-            f.filename for f in info.siblings
-            if f.filename.endswith(_WEIGHT_EXTS)
-        ]
-        raise FileNotFoundError(
-            f"No weight found. Available: {', '.join(available) or 'None'}"
-        )
+        if not actual_weight:
+            available = _weight_siblings(search_prefix or None)
+            # If prefix was a folder and defaults missing, unique weight under prefix
+            if len(available) == 1:
+                actual_weight = available[0]
+            elif not available and not search_prefix:
+                available = _weight_siblings(None)
+                if len(available) == 1:
+                    actual_weight = available[0]
+            if not actual_weight:
+                shown = available[:30] if available else _weight_siblings(None)[:30]
+                where = f" under '{search_prefix.rstrip('/')}'" if search_prefix else ""
+                raise FileNotFoundError(
+                    f"No weight found in {hub_repo}{where}. "
+                    f"Available: {', '.join(shown) or 'None'}"
+                )
+
+    # Validate nested path exists in repo file list when possible
+    sibling_names = {getattr(f, "filename", None) for f in siblings}
+    if actual_weight not in sibling_names:
+        # allow if list incomplete; still try exact match after strip
+        alt = actual_weight.lstrip("./")
+        if alt in sibling_names:
+            actual_weight = alt
+        else:
+            available = _weight_siblings(None)
+            # helpful: show nested matches by basename
+            base = Path(actual_weight).name
+            nested_hits = [a for a in available if a == actual_weight or a.endswith("/" + base)]
+            hint = nested_hits[:10] if nested_hits else available[:20]
+            raise FileNotFoundError(
+                f"Weight '{actual_weight}' not in {hub_repo}. "
+                f"Try nested path like 'subfolder/{base}'. Available: {', '.join(hint) or 'None'}"
+            )
 
     sha = None
-    for sib in info.siblings:
-        if sib.filename == actual_weight:
+    for sib in siblings:
+        if getattr(sib, "filename", None) == actual_weight:
             lfs = getattr(sib, "lfs", None) or {}
             if isinstance(lfs, dict):
                 sha = lfs.get("sha256") or lfs.get("oid")
             break
 
-    display = repo_id.split("/")[-1] if "/" in repo_id else repo_id
-    return repo_id, actual_weight, display, (str(sha).lower() if sha else None)
+    display = Path(actual_weight).stem if actual_weight else hub_repo.split("/")[-1]
+    return hub_repo, actual_weight, display, (str(sha).lower() if sha else None)
 
 
 def session_custom_lora_titles(dynamic_loras) -> list[str]: