Fix null-safety issues and apply code formatting

Bug fixes: - Add null guards for base_models_roots/embeddings_roots in backup cleanup - Fix null-safety initialization of extra_unet_roots Formatting: - Apply consistent code style across Python files - Fix line wrapping, quote consistency, and trailing commas - Add type ignore comments for dynamic/platform-specific code
2026-03-24 22:52:12 -03:00 · 2026-02-28 21:38:41 +08:00
parent b005961ee5
commit c9e5ea42cb
9 changed files with 1097 additions and 760 deletions
--- a/py/config.py
+++ b/py/config.py
@@ -2,7 +2,7 @@ import os
 import platform
 import threading
 from pathlib import Path
-import folder_paths # type: ignore
+import folder_paths  # type: ignore
 from typing import Any, Dict, Iterable, List, Mapping, Optional, Set, Tuple
 import logging
 import json
@@ -10,16 +10,23 @@ import urllib.parse
 import time

 from .utils.cache_paths import CacheType, get_cache_file_path, get_legacy_cache_paths
-from .utils.settings_paths import ensure_settings_file, get_settings_dir, load_settings_template
+from .utils.settings_paths import (
+    ensure_settings_file,
+    get_settings_dir,
+    load_settings_template,
+)

 # Use an environment variable to control standalone mode
-standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
+standalone_mode = (
+    os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"
+    or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
+)

 logger = logging.getLogger(__name__)


 def _normalize_folder_paths_for_comparison(
-    folder_paths: Mapping[str, Iterable[str]]
+    folder_paths: Mapping[str, Iterable[str]],
 ) -> Dict[str, Set[str]]:
    """Normalize folder paths for comparison across libraries."""

@@ -49,7 +56,7 @@ def _normalize_folder_paths_for_comparison(


 def _normalize_library_folder_paths(
-    library_payload: Mapping[str, Any]
+    library_payload: Mapping[str, Any],
 ) -> Dict[str, Set[str]]:
    """Return normalized folder paths extracted from a library payload."""

@@ -74,11 +81,17 @@ def _get_template_folder_paths() -> Dict[str, Set[str]]:

 class Config:
    """Global configuration for LoRA Manager"""
-    
+
    def __init__(self):
-        self.templates_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'templates')
-        self.static_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'static')
-        self.i18n_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'locales')
+        self.templates_path = os.path.join(
+            os.path.dirname(os.path.dirname(__file__)), "templates"
+        )
+        self.static_path = os.path.join(
+            os.path.dirname(os.path.dirname(__file__)), "static"
+        )
+        self.i18n_path = os.path.join(
+            os.path.dirname(os.path.dirname(__file__)), "locales"
+        )
        # Path mapping dictionary, target to link mapping
        self._path_mappings: Dict[str, str] = {}
        # Normalized preview root directories used to validate preview access
@@ -98,7 +111,7 @@ class Config:
        self.extra_embeddings_roots: List[str] = []
        # Scan symbolic links during initialization
        self._initialize_symlink_mappings()
-        
+
        if not standalone_mode:
            # Save the paths to settings.json when running in ComfyUI mode
            self.save_folder_paths_to_settings()
@@ -152,17 +165,21 @@ class Config:
                default_library = libraries.get("default", {})

            target_folder_paths = {
-                'loras': list(self.loras_roots),
-                'checkpoints': list(self.checkpoints_roots or []),
-                'unet': list(self.unet_roots or []),
-                'embeddings': list(self.embeddings_roots or []),
+                "loras": list(self.loras_roots),
+                "checkpoints": list(self.checkpoints_roots or []),
+                "unet": list(self.unet_roots or []),
+                "embeddings": list(self.embeddings_roots or []),
            }

-            normalized_target_paths = _normalize_folder_paths_for_comparison(target_folder_paths)
+            normalized_target_paths = _normalize_folder_paths_for_comparison(
+                target_folder_paths
+            )

            normalized_default_paths: Optional[Dict[str, Set[str]]] = None
            if isinstance(default_library, Mapping):
-                normalized_default_paths = _normalize_library_folder_paths(default_library)
+                normalized_default_paths = _normalize_library_folder_paths(
+                    default_library
+                )

            if (
                not comfy_library
@@ -185,13 +202,19 @@ class Config:
                default_lora_root = self.loras_roots[0]

            default_checkpoint_root = comfy_library.get("default_checkpoint_root", "")
-            if (not default_checkpoint_root and self.checkpoints_roots and
-                    len(self.checkpoints_roots) == 1):
+            if (
+                not default_checkpoint_root
+                and self.checkpoints_roots
+                and len(self.checkpoints_roots) == 1
+            ):
                default_checkpoint_root = self.checkpoints_roots[0]

            default_embedding_root = comfy_library.get("default_embedding_root", "")
-            if (not default_embedding_root and self.embeddings_roots and
-                    len(self.embeddings_roots) == 1):
+            if (
+                not default_embedding_root
+                and self.embeddings_roots
+                and len(self.embeddings_roots) == 1
+            ):
                default_embedding_root = self.embeddings_roots[0]

            metadata = dict(comfy_library.get("metadata", {}))
@@ -216,11 +239,12 @@ class Config:
        try:
            if os.path.islink(path):
                return True
-            if platform.system() == 'Windows':
+            if platform.system() == "Windows":
                try:
                    import ctypes
+
                    FILE_ATTRIBUTE_REPARSE_POINT = 0x400
-                    attrs = ctypes.windll.kernel32.GetFileAttributesW(str(path))
+                    attrs = ctypes.windll.kernel32.GetFileAttributesW(str(path))  # type: ignore[attr-defined]
                    return attrs != -1 and (attrs & FILE_ATTRIBUTE_REPARSE_POINT)
                except Exception as e:
                    logger.error(f"Error checking Windows reparse point: {e}")
@@ -233,18 +257,19 @@ class Config:
        """Check if a directory entry is a symlink, including Windows junctions."""
        if entry.is_symlink():
            return True
-        if platform.system() == 'Windows':
+        if platform.system() == "Windows":
            try:
                import ctypes
+
                FILE_ATTRIBUTE_REPARSE_POINT = 0x400
-                attrs = ctypes.windll.kernel32.GetFileAttributesW(entry.path)
+                attrs = ctypes.windll.kernel32.GetFileAttributesW(entry.path)  # type: ignore[attr-defined]
                return attrs != -1 and (attrs & FILE_ATTRIBUTE_REPARSE_POINT)
            except Exception:
                pass
        return False

    def _normalize_path(self, path: str) -> str:
-        return os.path.normpath(path).replace(os.sep, '/')
+        return os.path.normpath(path).replace(os.sep, "/")

    def _get_symlink_cache_path(self) -> Path:
        canonical_path = get_cache_file_path(CacheType.SYMLINK, create_dir=True)
@@ -278,19 +303,18 @@ class Config:
                            if self._entry_is_symlink(entry):
                                try:
                                    target = os.path.realpath(entry.path)
-                                    direct_symlinks.append([
-                                        self._normalize_path(entry.path),
-                                        self._normalize_path(target)
-                                    ])
+                                    direct_symlinks.append(
+                                        [
+                                            self._normalize_path(entry.path),
+                                            self._normalize_path(target),
+                                        ]
+                                    )
                                except OSError:
                                    pass
            except (OSError, PermissionError):
                pass

-        return {
-            "roots": unique_roots,
-            "direct_symlinks": sorted(direct_symlinks)
-        }
+        return {"roots": unique_roots, "direct_symlinks": sorted(direct_symlinks)}

    def _initialize_symlink_mappings(self) -> None:
        start = time.perf_counter()
@@ -307,10 +331,14 @@ class Config:
            cached_fingerprint = self._cached_fingerprint

            # Check 1: First-level symlinks unchanged (catches new symlinks at root)
-            fingerprint_valid = cached_fingerprint and current_fingerprint == cached_fingerprint
+            fingerprint_valid = (
+                cached_fingerprint and current_fingerprint == cached_fingerprint
+            )

            # Check 2: All cached mappings still valid (catches changes at any depth)
-            mappings_valid = self._validate_cached_mappings() if fingerprint_valid else False
+            mappings_valid = (
+                self._validate_cached_mappings() if fingerprint_valid else False
+            )

            if fingerprint_valid and mappings_valid:
                return
@@ -370,7 +398,9 @@ class Config:
        for target, link in cached_mappings.items():
            if not isinstance(target, str) or not isinstance(link, str):
                continue
-            normalized_mappings[self._normalize_path(target)] = self._normalize_path(link)
+            normalized_mappings[self._normalize_path(target)] = self._normalize_path(
+                link
+            )

        self._path_mappings = normalized_mappings

@@ -391,7 +421,9 @@ class Config:
                        parent_dir = loaded_path.parent
                        if parent_dir.name == "cache" and not any(parent_dir.iterdir()):
                            parent_dir.rmdir()
-                            logger.info("Removed empty legacy cache directory: %s", parent_dir)
+                            logger.info(
+                                "Removed empty legacy cache directory: %s", parent_dir
+                            )
                    except Exception:
                        pass

@@ -402,7 +434,9 @@ class Config:
                    exc,
                )
        else:
-            logger.info("Symlink cache loaded with %d mappings", len(self._path_mappings))
+            logger.info(
+                "Symlink cache loaded with %d mappings", len(self._path_mappings)
+            )

        return True

@@ -414,7 +448,7 @@ class Config:
        """
        for target, link in self._path_mappings.items():
            # Convert normalized paths back to OS paths
-            link_path = link.replace('/', os.sep)
+            link_path = link.replace("/", os.sep)

            # Check if symlink still exists
            if not self._is_link(link_path):
@@ -427,7 +461,9 @@ class Config:
                if actual_target != target:
                    logger.debug(
                        "Symlink target changed: %s -> %s (cached: %s)",
-                        link_path, actual_target, target
+                        link_path,
+                        actual_target,
+                        target,
                    )
                    return False
            except OSError:
@@ -446,7 +482,11 @@ class Config:
        try:
            with cache_path.open("w", encoding="utf-8") as handle:
                json.dump(payload, handle, ensure_ascii=False, indent=2)
-            logger.debug("Symlink cache saved to %s with %d mappings", cache_path, len(self._path_mappings))
+            logger.debug(
+                "Symlink cache saved to %s with %d mappings",
+                cache_path,
+                len(self._path_mappings),
+            )
        except Exception as exc:
            logger.info("Failed to write symlink cache %s: %s", cache_path, exc)

@@ -458,7 +498,7 @@ class Config:
        at the root level only (not nested symlinks in subdirectories).
        """
        start = time.perf_counter()
-        
+
        # Reset mappings before rescanning to avoid stale entries
        self._path_mappings.clear()
        self._seed_root_symlink_mappings()
@@ -472,7 +512,7 @@ class Config:

    def _scan_first_level_symlinks(self, root: str):
        """Scan only the first level of a directory for symlinks.
-        
+
        This avoids traversing the entire directory tree which can be extremely
        slow for large model collections. Only symlinks directly under the root
        are detected.
@@ -494,13 +534,13 @@ class Config:
                        self.add_path_mapping(entry.path, target_path)
                    except Exception as inner_exc:
                        logger.debug(
-                            "Error processing directory entry %s: %s", entry.path, inner_exc
+                            "Error processing directory entry %s: %s",
+                            entry.path,
+                            inner_exc,
                        )
        except Exception as e:
            logger.error(f"Error scanning links in {root}: {e}")

-
-
    def add_path_mapping(self, link_path: str, target_path: str):
        """Add a symbolic link path mapping
        target_path: actual target path
@@ -594,41 +634,46 @@ class Config:
            preview_roots.update(self._expand_preview_root(target))
            preview_roots.update(self._expand_preview_root(link))

-        self._preview_root_paths = {path for path in preview_roots if path.is_absolute()}
+        self._preview_root_paths = {
+            path for path in preview_roots if path.is_absolute()
+        }
        logger.debug(
            "Preview roots rebuilt: %d paths from %d lora roots (%d extra), %d checkpoint roots (%d extra), %d embedding roots (%d extra), %d symlink mappings",
            len(self._preview_root_paths),
-            len(self.loras_roots or []), len(self.extra_loras_roots or []),
-            len(self.base_models_roots or []), len(self.extra_checkpoints_roots or []),
-            len(self.embeddings_roots or []), len(self.extra_embeddings_roots or []),
+            len(self.loras_roots or []),
+            len(self.extra_loras_roots or []),
+            len(self.base_models_roots or []),
+            len(self.extra_checkpoints_roots or []),
+            len(self.embeddings_roots or []),
+            len(self.extra_embeddings_roots or []),
            len(self._path_mappings),
        )

    def map_path_to_link(self, path: str) -> str:
        """Map a target path back to its symbolic link path"""
-        normalized_path = os.path.normpath(path).replace(os.sep, '/')
+        normalized_path = os.path.normpath(path).replace(os.sep, "/")
        # Check if the path is contained in any mapped target path
        for target_path, link_path in self._path_mappings.items():
            # Match whole path components to avoid prefix collisions (e.g., /a/b vs /a/bc)
            if normalized_path == target_path:
                return link_path
-            
-            if normalized_path.startswith(target_path + '/'):
+
+            if normalized_path.startswith(target_path + "/"):
                # If the path starts with the target path, replace with link path
                mapped_path = normalized_path.replace(target_path, link_path, 1)
                return mapped_path
        return normalized_path
-    
+
    def map_link_to_path(self, link_path: str) -> str:
        """Map a symbolic link path back to the actual path"""
-        normalized_link = os.path.normpath(link_path).replace(os.sep, '/')
+        normalized_link = os.path.normpath(link_path).replace(os.sep, "/")
        # Check if the path is contained in any mapped target path
        for target_path, link_path_mapped in self._path_mappings.items():
            # Match whole path components
            if normalized_link == link_path_mapped:
                return target_path

-            if normalized_link.startswith(link_path_mapped + '/'):
+            if normalized_link.startswith(link_path_mapped + "/"):
                # If the path starts with the link path, replace with actual path
                mapped_path = normalized_link.replace(link_path_mapped, target_path, 1)
                return mapped_path
@@ -641,8 +686,8 @@ class Config:
                continue
            if not os.path.exists(path):
                continue
-            real_path = os.path.normpath(os.path.realpath(path)).replace(os.sep, '/')
-            normalized = os.path.normpath(path).replace(os.sep, '/')
+            real_path = os.path.normpath(os.path.realpath(path)).replace(os.sep, "/")
+            normalized = os.path.normpath(path).replace(os.sep, "/")
            if real_path not in dedup:
                dedup[real_path] = normalized
        return dedup
@@ -652,7 +697,9 @@ class Config:
        unique_paths = sorted(path_map.values(), key=lambda p: p.lower())

        for original_path in unique_paths:
-            real_path = os.path.normpath(os.path.realpath(original_path)).replace(os.sep, '/')
+            real_path = os.path.normpath(os.path.realpath(original_path)).replace(
+                os.sep, "/"
+            )
            if real_path != original_path:
                self.add_path_mapping(original_path, real_path)

@@ -674,7 +721,7 @@ class Config:
                "Please fix your ComfyUI path configuration to separate these folders. "
                "Falling back to 'checkpoints' for backward compatibility. "
                "Overlapping real paths: %s",
-                [checkpoint_map.get(rp, rp) for rp in overlapping_real_paths]
+                [checkpoint_map.get(rp, rp) for rp in overlapping_real_paths],
            )
            # Remove overlapping paths from unet_map to prioritize checkpoints
            for rp in overlapping_real_paths:
@@ -694,7 +741,9 @@ class Config:
        self.unet_roots = [p for p in unique_paths if p in unet_values]

        for original_path in unique_paths:
-            real_path = os.path.normpath(os.path.realpath(original_path)).replace(os.sep, '/')
+            real_path = os.path.normpath(os.path.realpath(original_path)).replace(
+                os.sep, "/"
+            )
            if real_path != original_path:
                self.add_path_mapping(original_path, real_path)

@@ -705,7 +754,9 @@ class Config:
        unique_paths = sorted(path_map.values(), key=lambda p: p.lower())

        for original_path in unique_paths:
-            real_path = os.path.normpath(os.path.realpath(original_path)).replace(os.sep, '/')
+            real_path = os.path.normpath(os.path.realpath(original_path)).replace(
+                os.sep, "/"
+            )
            if real_path != original_path:
                self.add_path_mapping(original_path, real_path)

@@ -719,42 +770,66 @@ class Config:
        self._path_mappings.clear()
        self._preview_root_paths = set()

-        lora_paths = folder_paths.get('loras', []) or []
-        checkpoint_paths = folder_paths.get('checkpoints', []) or []
-        unet_paths = folder_paths.get('unet', []) or []
-        embedding_paths = folder_paths.get('embeddings', []) or []
+        lora_paths = folder_paths.get("loras", []) or []
+        checkpoint_paths = folder_paths.get("checkpoints", []) or []
+        unet_paths = folder_paths.get("unet", []) or []
+        embedding_paths = folder_paths.get("embeddings", []) or []

        self.loras_roots = self._prepare_lora_paths(lora_paths)
-        self.base_models_roots = self._prepare_checkpoint_paths(checkpoint_paths, unet_paths)
+        self.base_models_roots = self._prepare_checkpoint_paths(
+            checkpoint_paths, unet_paths
+        )
        self.embeddings_roots = self._prepare_embedding_paths(embedding_paths)

        # Process extra paths (only for LoRA Manager, not shared with ComfyUI)
        extra_paths = extra_folder_paths or {}
-        extra_lora_paths = extra_paths.get('loras', []) or []
-        extra_checkpoint_paths = extra_paths.get('checkpoints', []) or []
-        extra_unet_paths = extra_paths.get('unet', []) or []
-        extra_embedding_paths = extra_paths.get('embeddings', []) or []
+        extra_lora_paths = extra_paths.get("loras", []) or []
+        extra_checkpoint_paths = extra_paths.get("checkpoints", []) or []
+        extra_unet_paths = extra_paths.get("unet", []) or []
+        extra_embedding_paths = extra_paths.get("embeddings", []) or []

        self.extra_loras_roots = self._prepare_lora_paths(extra_lora_paths)
        # Save main paths before processing extra paths ( _prepare_checkpoint_paths overwrites them)
        saved_checkpoints_roots = self.checkpoints_roots
        saved_unet_roots = self.unet_roots
-        self.extra_checkpoints_roots = self._prepare_checkpoint_paths(extra_checkpoint_paths, extra_unet_paths)
-        self.extra_unet_roots = self.unet_roots  # unet_roots was set by _prepare_checkpoint_paths
+        self.extra_checkpoints_roots = self._prepare_checkpoint_paths(
+            extra_checkpoint_paths, extra_unet_paths
+        )
+        self.extra_unet_roots = (
+            self.unet_roots if self.unet_roots is not None else []
+        )  # unet_roots was set by _prepare_checkpoint_paths
        # Restore main paths
        self.checkpoints_roots = saved_checkpoints_roots
        self.unet_roots = saved_unet_roots
-        self.extra_embeddings_roots = self._prepare_embedding_paths(extra_embedding_paths)
+        self.extra_embeddings_roots = self._prepare_embedding_paths(
+            extra_embedding_paths
+        )

        # Log extra folder paths
        if self.extra_loras_roots:
-            logger.info("Found extra LoRA roots:" + "\n - " + "\n - ".join(self.extra_loras_roots))
+            logger.info(
+                "Found extra LoRA roots:"
+                + "\n - "
+                + "\n - ".join(self.extra_loras_roots)
+            )
        if self.extra_checkpoints_roots:
-            logger.info("Found extra checkpoint roots:" + "\n - " + "\n - ".join(self.extra_checkpoints_roots))
+            logger.info(
+                "Found extra checkpoint roots:"
+                + "\n - "
+                + "\n - ".join(self.extra_checkpoints_roots)
+            )
        if self.extra_unet_roots:
-            logger.info("Found extra diffusion model roots:" + "\n - " + "\n - ".join(self.extra_unet_roots))
+            logger.info(
+                "Found extra diffusion model roots:"
+                + "\n - "
+                + "\n - ".join(self.extra_unet_roots)
+            )
        if self.extra_embeddings_roots:
-            logger.info("Found extra embedding roots:" + "\n - " + "\n - ".join(self.extra_embeddings_roots))
+            logger.info(
+                "Found extra embedding roots:"
+                + "\n - "
+                + "\n - ".join(self.extra_embeddings_roots)
+            )

        self._initialize_symlink_mappings()

@@ -763,7 +838,10 @@ class Config:
        try:
            raw_paths = folder_paths.get_folder_paths("loras")
            unique_paths = self._prepare_lora_paths(raw_paths)
-            logger.info("Found LoRA roots:" + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]"))
+            logger.info(
+                "Found LoRA roots:"
+                + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]")
+            )

            if not unique_paths:
                logger.warning("No valid loras folders found in ComfyUI configuration")
@@ -779,12 +857,19 @@ class Config:
        try:
            raw_checkpoint_paths = folder_paths.get_folder_paths("checkpoints")
            raw_unet_paths = folder_paths.get_folder_paths("unet")
-            unique_paths = self._prepare_checkpoint_paths(raw_checkpoint_paths, raw_unet_paths)
+            unique_paths = self._prepare_checkpoint_paths(
+                raw_checkpoint_paths, raw_unet_paths
+            )

-            logger.info("Found checkpoint roots:" + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]"))
+            logger.info(
+                "Found checkpoint roots:"
+                + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]")
+            )

            if not unique_paths:
-                logger.warning("No valid checkpoint folders found in ComfyUI configuration")
+                logger.warning(
+                    "No valid checkpoint folders found in ComfyUI configuration"
+                )
                return []

            return unique_paths
@@ -797,10 +882,15 @@ class Config:
        try:
            raw_paths = folder_paths.get_folder_paths("embeddings")
            unique_paths = self._prepare_embedding_paths(raw_paths)
-            logger.info("Found embedding roots:" + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]"))
+            logger.info(
+                "Found embedding roots:"
+                + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]")
+            )

            if not unique_paths:
-                logger.warning("No valid embeddings folders found in ComfyUI configuration")
+                logger.warning(
+                    "No valid embeddings folders found in ComfyUI configuration"
+                )
                return []

            return unique_paths
@@ -812,13 +902,13 @@ class Config:
        if not preview_path:
            return ""

-        normalized = os.path.normpath(preview_path).replace(os.sep, '/')
-        encoded_path = urllib.parse.quote(normalized, safe='')
-        return f'/api/lm/previews?path={encoded_path}'
+        normalized = os.path.normpath(preview_path).replace(os.sep, "/")
+        encoded_path = urllib.parse.quote(normalized, safe="")
+        return f"/api/lm/previews?path={encoded_path}"

    def is_preview_path_allowed(self, preview_path: str) -> bool:
        """Return ``True`` if ``preview_path`` is within an allowed directory.
-        
+
        If the path is initially rejected, attempts to discover deep symlinks
        that were not scanned during initialization. If a symlink is found,
        updates the in-memory path mappings and retries the check.
@@ -889,14 +979,18 @@ class Config:
                        normalized_link = self._normalize_path(str(current))

                        self._path_mappings[normalized_target] = normalized_link
-                        self._preview_root_paths.update(self._expand_preview_root(normalized_target))
-                        self._preview_root_paths.update(self._expand_preview_root(normalized_link))
+                        self._preview_root_paths.update(
+                            self._expand_preview_root(normalized_target)
+                        )
+                        self._preview_root_paths.update(
+                            self._expand_preview_root(normalized_link)
+                        )

                        logger.debug(
                            "Discovered deep symlink: %s -> %s (preview path: %s)",
                            normalized_link,
                            normalized_target,
-                            preview_path
+                            preview_path,
                        )

                        return True
@@ -914,8 +1008,16 @@ class Config:

    def apply_library_settings(self, library_config: Mapping[str, object]) -> None:
        """Update runtime paths to match the provided library configuration."""
-        folder_paths = library_config.get('folder_paths') if isinstance(library_config, Mapping) else {}
-        extra_folder_paths = library_config.get('extra_folder_paths') if isinstance(library_config, Mapping) else None
+        folder_paths = (
+            library_config.get("folder_paths")
+            if isinstance(library_config, Mapping)
+            else {}
+        )
+        extra_folder_paths = (
+            library_config.get("extra_folder_paths")
+            if isinstance(library_config, Mapping)
+            else None
+        )
        if not isinstance(folder_paths, Mapping):
            folder_paths = {}
        if not isinstance(extra_folder_paths, Mapping):
@@ -925,9 +1027,12 @@ class Config:

        logger.info(
            "Applied library settings with %d lora roots (%d extra), %d checkpoint roots (%d extra), and %d embedding roots (%d extra)",
-            len(self.loras_roots or []), len(self.extra_loras_roots or []),
-            len(self.base_models_roots or []), len(self.extra_checkpoints_roots or []),
-            len(self.embeddings_roots or []), len(self.extra_embeddings_roots or []),
+            len(self.loras_roots or []),
+            len(self.extra_loras_roots or []),
+            len(self.base_models_roots or []),
+            len(self.extra_checkpoints_roots or []),
+            len(self.embeddings_roots or []),
+            len(self.extra_embeddings_roots or []),
        )

    def get_library_registry_snapshot(self) -> Dict[str, object]:
@@ -947,5 +1052,6 @@ class Config:
            logger.debug("Failed to collect library registry snapshot: %s", exc)
            return {"active_library": "", "libraries": {}}

+
 # Global config instance
 config = Config()