feat(example-images): namespace storage by library

py/services/example_images_cleanup_service.py

@@ -8,10 +8,11 @@ import os
 import shutil
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, List
+from typing import Dict, List, Tuple
 
 from .service_registry import ServiceRegistry
 from .settings_manager import settings
+from ..utils.example_images_paths import iter_library_roots
 
 
 logger = logging.getLogger(__name__)
@@ -70,9 +71,9 @@ class ExampleImagesCleanupService:
                 "error_code": "path_not_configured",
             }
 
-        example_root = Path(example_images_path)
-        if not example_root.exists():
-            logger.debug("Cleanup skipped: example images path missing -> %s", example_root)
+        base_root = Path(example_images_path)
+        if not base_root.exists():
+            logger.debug("Cleanup skipped: example images path missing -> %s", base_root)
             return {
                 "success": False,
                 "error": "Example images path does not exist.",
@@ -91,9 +92,6 @@ class ExampleImagesCleanupService:
                 "error_code": "scanner_initialization_failed",
             }
 
-        deleted_bucket = example_root / self._deleted_folder_name
-        deleted_bucket.mkdir(exist_ok=True)
-
         checked_folders = 0
         moved_empty = 0
         moved_orphaned = 0
@@ -101,45 +99,96 @@ class ExampleImagesCleanupService:
         move_failures = 0
         errors: List[str] = []
 
-        for entry in os.scandir(example_root):
-            if not entry.is_dir(follow_symlinks=False):
+        resolved_base = base_root.resolve()
+        library_paths: List[Tuple[str, Path]] = []
+        processed_paths = {resolved_base}
+
+        for library_name, library_path in iter_library_roots():
+            if not library_path:
                 continue
-
-            if entry.name == self._deleted_folder_name:
-                continue
-
-            checked_folders += 1
-            folder_path = Path(entry.path)
-
+            library_root = Path(library_path)
             try:
-                if self._is_folder_empty(folder_path):
-                    if await self._remove_empty_folder(folder_path):
-                        moved_empty += 1
-                    else:
-                        move_failures += 1
-                    continue
-
-                if not self._is_hash_folder(entry.name):
-                    skipped_non_hash += 1
-                    continue
-
-                hash_exists = (
-                    lora_scanner.has_hash(entry.name)
-                    or checkpoint_scanner.has_hash(entry.name)
-                    or embedding_scanner.has_hash(entry.name)
+                resolved = library_root.resolve()
+            except FileNotFoundError:
+                continue
+            if resolved in processed_paths:
+                continue
+            if not library_root.exists():
+                logger.debug(
+                    "Skipping cleanup for library '%s': folder missing (%s)",
+                    library_name,
+                    library_root,
                 )
+                continue
+            processed_paths.add(resolved)
+            library_paths.append((library_name, library_root))
 
-                if not hash_exists:
-                    if await self._move_folder(folder_path, deleted_bucket):
-                        moved_orphaned += 1
-                    else:
-                        move_failures += 1
+        deleted_roots: List[Path] = []
 
-            except Exception as exc:  # pragma: no cover - filesystem guard
-                move_failures += 1
-                error_message = f"{entry.name}: {exc}"
-                errors.append(error_message)
-                logger.error("Error processing example images folder %s: %s", folder_path, exc, exc_info=True)
+        # Build list of (label, root) pairs including the base root for legacy layouts
+        cleanup_targets: List[Tuple[str, Path]] = [("__base__", base_root)] + library_paths
+
+        library_root_set = {root.resolve() for _, root in library_paths}
+
+        for label, root_path in cleanup_targets:
+            deleted_bucket = root_path / self._deleted_folder_name
+            deleted_bucket.mkdir(exist_ok=True)
+            deleted_roots.append(deleted_bucket)
+
+            for entry in os.scandir(root_path):
+                if not entry.is_dir(follow_symlinks=False):
+                    continue
+
+                if entry.name == self._deleted_folder_name:
+                    continue
+
+                entry_path = Path(entry.path)
+
+                if label == "__base__":
+                    try:
+                        resolved_entry = entry_path.resolve()
+                    except FileNotFoundError:
+                        continue
+                    if resolved_entry in library_root_set:
+                        # Skip library-specific folders tracked separately
+                        continue
+
+                checked_folders += 1
+
+                try:
+                    if self._is_folder_empty(entry_path):
+                        if await self._remove_empty_folder(entry_path):
+                            moved_empty += 1
+                        else:
+                            move_failures += 1
+                        continue
+
+                    if not self._is_hash_folder(entry.name):
+                        skipped_non_hash += 1
+                        continue
+
+                    hash_exists = (
+                        lora_scanner.has_hash(entry.name)
+                        or checkpoint_scanner.has_hash(entry.name)
+                        or embedding_scanner.has_hash(entry.name)
+                    )
+
+                    if not hash_exists:
+                        if await self._move_folder(entry_path, deleted_bucket):
+                            moved_orphaned += 1
+                        else:
+                            move_failures += 1
+
+                except Exception as exc:  # pragma: no cover - filesystem guard
+                    move_failures += 1
+                    error_message = f"{entry.name}: {exc}"
+                    errors.append(error_message)
+                    logger.error(
+                        "Error processing example images folder %s: %s",
+                        entry_path,
+                        exc,
+                        exc_info=True,
+                    )
 
         partial_success = move_failures > 0 and (moved_empty > 0 or moved_orphaned > 0)
         success = move_failures == 0 and not errors
@@ -152,11 +201,12 @@ class ExampleImagesCleanupService:
             skipped_non_hash=skipped_non_hash,
             move_failures=move_failures,
             errors=errors,
-            deleted_root=str(deleted_bucket),
+            deleted_root=str(deleted_roots[0]) if deleted_roots else None,
             partial_success=partial_success,
         )
 
         summary = result.to_dict()
+        summary["deleted_roots"] = [str(path) for path in deleted_roots]
         if success:
             logger.info(
                 "Example images cleanup complete: checked=%s, moved_empty=%s, moved_orphaned=%s",