refactor: remove dead and test-only code and the write-only prompt registry (#620)

Removes helpers nothing calls, test-only wrappers and their tests, the unused
config writer, three unused images, and the prompt registry the nodes wrote to
but nothing read, which grew with every run.

py/api/__init__.py

@@ -89,7 +89,6 @@ from .source_rescope import SourceRescopeMixin
 
 try:
     from ...database.operations import PromptDatabase
-    from ...utils.file_prompt import parse_comfyui_prompt
     from ...utils.logging_config import get_logger
     from ...utils.native_memory import release_free_memory
     from ...utils.png_text import png_text
@@ -101,7 +100,6 @@ except ImportError:
         0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
     )
     from database.operations import PromptDatabase
-    from utils.file_prompt import parse_comfyui_prompt
     from utils.logging_config import get_logger
     from utils.native_memory import release_free_memory
     from utils.png_text import png_text
@@ -254,23 +252,6 @@ async def _read_json_body(request, max_bytes=JSON_BODY_MAX_BYTES):
     return data, None
 
 
-class _LongJobGuard:
-    """Async context manager handed out by ``_acquire_long_job``."""
-
-    def __init__(self, lock):
-        self._lock = lock
-
-    async def __aenter__(self):
-        # The caller checked ``locked()`` on this same loop iteration, so this
-        # acquire never waits.
-        await self._lock.acquire()
-        return self
-
-    async def __aexit__(self, exc_type, exc, tb):
-        self._lock.release()
-        return False
-
-
 # ── Gzip compression middleware ────────────────────────────────────────
 _GZIP_MIN_SIZE = 1024  # Only compress bodies larger than 1 KB
 _GZIP_TYPES = frozenset(
@@ -426,10 +407,6 @@ class PromptManagerAPI(
         self._workspace_card_cache = {}
         # Favorite keys of each root's cached scan (images._favorite_listing).
         self._favorite_listing_cache = {}
-        # Single-flight locks for long jobs, keyed by job family; see
-        # _acquire_long_job(). Created lazily so no lock binds to an event
-        # loop before the server's loop exists.
-        self._long_jobs: dict = {}
         # This session's jobs (py/api/jobs.py): the metadata scan, and later
         # every other long operation the Activity page tracks.
         self._jobs = JobRegistry(self.logger)
@@ -486,26 +463,6 @@ class PromptManagerAPI(
     _public_error = staticmethod(_public_error)
     _read_json_body = staticmethod(_read_json_body)
 
-    def _acquire_long_job(self, name):
-        """Claim the single-flight slot for a long job family, or None when busy.
-
-        Usage in a handler::
-
-            job = self._acquire_long_job("duplicates")
-            if job is None:
-                return self._long_job_busy_response("Duplicate scan")
-            async with job:
-                ...
-
-        Families are free-form strings ("duplicates", "thumbnails",
-        "autotag", ...); the lock is released when the ``async with`` block
-        exits, including on exceptions. Must be called from the event loop.
-        """
-        lock = self._long_jobs.setdefault(name, asyncio.Lock())
-        if lock.locked():
-            return None
-        return _LongJobGuard(lock)
-
     @staticmethod
     def _long_job_busy_response(label):
         """409 envelope for a long job that is already running."""
@@ -1079,7 +1036,3 @@ class PromptManagerAPI(
                 f"Unreadable image {os.path.basename(str(image_path))}: {e}"
             )
             return {}
-
-    def _parse_comfyui_prompt(self, metadata):
-        """Parse ComfyUI and A1111 prompt data from metadata."""
-        return parse_comfyui_prompt(metadata)

py/api/autotag_routes.py

@@ -943,16 +943,6 @@ class AutotagRoutesMixin:
             return refusal.response
         return web.json_response({"success": True, "job": job.summary()}, status=202)
 
-    def _gated_runner(self, owner):
-        """Executor calls under the model gate *owner* holds (plain when None)."""
-        if owner is None:
-            return self._run_in_executor
-
-        async def run(func, *args, **kwargs):
-            return await model_gate.run(owner, func, *args, **kwargs)
-
-        return run
-
     def _resolve_allowed_image_path(self, raw_path: str) -> Optional[str]:
         """Return the real path when it is a media file inside an output directory."""
         if Path(str(raw_path)).suffix.lower() not in _MEDIA_EXTENSIONS:

py/api/thumbnail_auto.py

@@ -632,10 +632,6 @@ class AutoThumbnailer:
         """True once the worker has nothing queued or in hand."""
         return self._wait_for(lambda: not self._busy, timeout)
 
-    def wait_batch(self, size, timeout=None):
-        """True once the worker holds a batch of *size* files."""
-        return self._wait_for(lambda: self._batch == size, timeout)
-
 
 class _PreviewGate:
     """Admission of view requests on the event loop (#249 I2).
@@ -967,15 +963,6 @@ class AutoThumbnailMixin:
             return "queued"
         return "skipped"
 
-    def _capture_target(self, image_path):
-        """``(src, dst, is_video)`` of a new output's preview now, or None."""
-        located = self._capture_source(image_path)
-        if located is None:
-            return None
-        src, root, rel, is_video = located
-        dst = DeferredPreview(root, rel).resolve()
-        return None if dst is None else (src, dst, is_video)
-
     def _capture_source(self, image_path):
         """``(src, root, rel, is_video)`` of a media file under a current
         root (not a preview, a link or in a trash folder), or None."""

py/api/thumbnail_jobs.py

@@ -90,7 +90,7 @@ class ThumbnailOptions:
         }
 
 
-def thumbnail_options(raw, *, from_query=False):
+def thumbnail_options(raw):
     """``(ThumbnailOptions, None)`` from a body or query, or ``(None, message)``.
 
     An absent mode is ``missing``; the settings are the server's now.
@@ -136,7 +136,7 @@ class ThumbnailJobsMixin:
         ``mode=prune`` lists the removed sources' thumbnails (#320)."""
         if request.query.get("mode") == "prune":
             return await self.get_prune_plan()
-        options, error = thumbnail_options(request.query, from_query=True)
+        options, error = thumbnail_options(request.query)
         if error:
             return _invalid(error)
         try:

py/config.py

@@ -78,27 +78,6 @@ def _canonical_path(path: str) -> str:
     return os.path.normcase(os.path.realpath(path))
 
 
-def write_private_json(path: str, data: Any) -> None:
-    """Write ``data`` as JSON to ``path`` readable by the current user only.
-
-    config.json can hold an API key (integrations.lora_manager), so it is
-    created with mode 0600 and, on POSIX, an existing more open file is
-    tightened too. Windows has no POSIX modes; there the chmod is a best
-    effort that only affects the read-only bit. Parent directories are
-    created as needed. Raises OSError when the file cannot be written.
-    """
-    import json
-
-    parent_dir = os.path.dirname(path)
-    if parent_dir:
-        os.makedirs(parent_dir, exist_ok=True)
-    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
-    with os.fdopen(fd, "w", encoding="utf-8") as f:
-        json.dump(data, f, indent=2)
-    if os.name == "posix":
-        os.chmod(path, 0o600)
-
-
 def _lexical_path(path: str) -> str:
     """``path`` normalised for comparison without touching the filesystem.
 
@@ -717,12 +696,6 @@ class AutotagConfig:
     def suggestion_limit(cls) -> int:
         return cls.SUGGESTION_LIMIT
 
-    @staticmethod
-    def valid_suggestion_limit(value: Any) -> bool:
-        return (
-            type(value) is int and 1 <= value <= MAX_SUGGESTION_LIMIT
-        )  # bool, float and str are rejected
-
     @classmethod
     def all_instructions(cls) -> List[Dict[str, str]]:
         """Built-in first, then the saved entries (copies)."""
@@ -1063,35 +1036,6 @@ class PromptManagerConfig:
         else:
             config_logger.info(f"Config file not found: {config_path}, using defaults")
 
-    @classmethod
-    def save_to_file(cls, config_path: Optional[str] = None):
-        """Save the current configuration to a JSON file.
-
-        Serializes the complete configuration (including gallery settings) to
-        a JSON file. Creates the directory structure if it doesn't exist.
-
-        Args:
-            config_path (str): Path where the JSON configuration file should be saved.
-                            Parent directories will be created if they don't exist.
-                            Defaults to :meth:`get_config_path`.
-
-        Raises:
-            The method handles all exceptions internally and logs errors rather
-            than propagating them.
-
-        Example:
-            PromptManagerConfig.save_to_file('backup_config.json')
-            PromptManagerConfig.save_to_file('/etc/comfyui/prompt_manager.json')
-        """
-        if config_path is None:
-            config_path = cls.get_config_path()
-
-        try:
-            write_private_json(config_path, cls.get_config())
-            config_logger.info(f"Saved configuration to {config_path}")
-        except Exception as e:
-            config_logger.error(f"Error saving config to {config_path}: {e}")
-
     @classmethod
     def update_config(cls, new_config: Dict[str, Any]):
         """Update configuration attributes from a dictionary.