chore: import upstream snapshot with attribution

invokeai/app/services/object_serializer/object_serializer_base.py

@@ -0,0 +1,44 @@
+from abc import ABC, abstractmethod
+from typing import Callable, Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class ObjectSerializerBase(ABC, Generic[T]):
+    """Saves and loads arbitrary python objects."""
+
+    def __init__(self) -> None:
+        self._on_deleted_callbacks: list[Callable[[str], None]] = []
+
+    @abstractmethod
+    def load(self, name: str) -> T:
+        """
+        Loads the object.
+        :param name: The name of the object to load.
+        :raises ObjectNotFoundError: if the object is not found
+        """
+        pass
+
+    @abstractmethod
+    def save(self, obj: T) -> str:
+        """
+        Saves the object, returning its name.
+        :param obj: The object to save.
+        """
+        pass
+
+    @abstractmethod
+    def delete(self, name: str) -> None:
+        """
+        Deletes the object, if it exists.
+        :param name: The name of the object to delete.
+        """
+        pass
+
+    def on_deleted(self, on_deleted: Callable[[str], None]) -> None:
+        """Register a callback for when an object is deleted"""
+        self._on_deleted_callbacks.append(on_deleted)
+
+    def _on_deleted(self, name: str) -> None:
+        for callback in self._on_deleted_callbacks:
+            callback(name)

invokeai/app/services/object_serializer/object_serializer_common.py

@@ -0,0 +1,5 @@
+class ObjectNotFoundError(KeyError):
+    """Raised when an object is not found while loading"""
+
+    def __init__(self, name: str) -> None:
+        super().__init__(f"Object with name {name} not found")

invokeai/app/services/object_serializer/object_serializer_disk.py

@@ -0,0 +1,93 @@
+import shutil
+import tempfile
+import typing
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional, TypeVar
+
+import torch
+
+from invokeai.app.services.object_serializer.object_serializer_base import ObjectSerializerBase
+from invokeai.app.services.object_serializer.object_serializer_common import ObjectNotFoundError
+from invokeai.app.util.misc import uuid_string
+
+if TYPE_CHECKING:
+    from invokeai.app.services.invoker import Invoker
+
+
+T = TypeVar("T")
+
+
+class ObjectSerializerDisk(ObjectSerializerBase[T]):
+    """Disk-backed storage for arbitrary python objects. Serialization is handled by `torch.save` and `torch.load`.
+
+    :param output_dir: The folder where the serialized objects will be stored
+    :param safe_globals: A list of types to be added to the safe globals for torch serialization
+    :param ephemeral: If True, objects will be stored in a temporary directory inside the given output_dir and cleaned up on exit
+    """
+
+    def __init__(
+        self,
+        output_dir: Path,
+        safe_globals: list[type],
+        ephemeral: bool = False,
+    ) -> None:
+        super().__init__()
+        self._ephemeral = ephemeral
+        self._base_output_dir = output_dir
+        self._base_output_dir.mkdir(parents=True, exist_ok=True)
+
+        if self._ephemeral:
+            # Remove dangling tempdirs that might have been left over from an earlier unplanned shutdown.
+            for temp_dir in filter(Path.is_dir, self._base_output_dir.glob("tmp*")):
+                shutil.rmtree(temp_dir)
+
+        # Must specify `ignore_cleanup_errors` to avoid fatal errors during cleanup on Windows
+        self._tempdir = (
+            tempfile.TemporaryDirectory(dir=self._base_output_dir, ignore_cleanup_errors=True) if ephemeral else None
+        )
+        self._output_dir = Path(self._tempdir.name) if self._tempdir else self._base_output_dir
+        self.__obj_class_name: Optional[str] = None
+
+        torch.serialization.add_safe_globals(safe_globals) if safe_globals else None
+
+    def load(self, name: str) -> T:
+        file_path = self._get_path(name)
+        try:
+            return torch.load(file_path)  # pyright: ignore [reportUnknownMemberType]
+        except FileNotFoundError as e:
+            raise ObjectNotFoundError(name) from e
+
+    def save(self, obj: T) -> str:
+        name = self._new_name()
+        file_path = self._get_path(name)
+        torch.save(obj, file_path)  # pyright: ignore [reportUnknownMemberType]
+        return name
+
+    def delete(self, name: str) -> None:
+        file_path = self._get_path(name)
+        file_path.unlink()
+
+    @property
+    def _obj_class_name(self) -> str:
+        if not self.__obj_class_name:
+            # `__orig_class__` is not available in the constructor for some technical, undoubtedly very pythonic reason
+            self.__obj_class_name = typing.get_args(self.__orig_class__)[0].__name__  # pyright: ignore [reportUnknownMemberType, reportAttributeAccessIssue]
+        return self.__obj_class_name
+
+    def _get_path(self, name: str) -> Path:
+        return self._output_dir / name
+
+    def _new_name(self) -> str:
+        return f"{self._obj_class_name}_{uuid_string()}"
+
+    def _tempdir_cleanup(self) -> None:
+        """Calls `cleanup` on the temporary directory, if it exists."""
+        if self._tempdir:
+            self._tempdir.cleanup()
+
+    def __del__(self) -> None:
+        # In case the service is not properly stopped, clean up the temporary directory when the class instance is GC'd.
+        self._tempdir_cleanup()
+
+    def stop(self, invoker: "Invoker") -> None:
+        self._tempdir_cleanup()

invokeai/app/services/object_serializer/object_serializer_forward_cache.py

@@ -0,0 +1,65 @@
+from queue import Queue
+from typing import TYPE_CHECKING, Optional, TypeVar
+
+from invokeai.app.services.object_serializer.object_serializer_base import ObjectSerializerBase
+
+T = TypeVar("T")
+
+if TYPE_CHECKING:
+    from invokeai.app.services.invoker import Invoker
+
+
+class ObjectSerializerForwardCache(ObjectSerializerBase[T]):
+    """
+    Provides a LRU cache for an instance of `ObjectSerializerBase`.
+    Saving an object to the cache always writes through to the underlying storage.
+    """
+
+    def __init__(self, underlying_storage: ObjectSerializerBase[T], max_cache_size: int = 20):
+        super().__init__()
+        self._underlying_storage = underlying_storage
+        self._cache: dict[str, T] = {}
+        self._cache_ids = Queue[str]()
+        self._max_cache_size = max_cache_size
+
+    def start(self, invoker: "Invoker") -> None:
+        self._invoker = invoker
+        start_op = getattr(self._underlying_storage, "start", None)
+        if callable(start_op):
+            start_op(invoker)
+
+    def stop(self, invoker: "Invoker") -> None:
+        self._invoker = invoker
+        stop_op = getattr(self._underlying_storage, "stop", None)
+        if callable(stop_op):
+            stop_op(invoker)
+
+    def load(self, name: str) -> T:
+        cache_item = self._get_cache(name)
+        if cache_item is not None:
+            return cache_item
+
+        obj = self._underlying_storage.load(name)
+        self._set_cache(name, obj)
+        return obj
+
+    def save(self, obj: T) -> str:
+        name = self._underlying_storage.save(obj)
+        self._set_cache(name, obj)
+        return name
+
+    def delete(self, name: str) -> None:
+        self._underlying_storage.delete(name)
+        if name in self._cache:
+            del self._cache[name]
+        self._on_deleted(name)
+
+    def _get_cache(self, name: str) -> Optional[T]:
+        return None if name not in self._cache else self._cache[name]
+
+    def _set_cache(self, name: str, data: T):
+        if name not in self._cache:
+            self._cache[name] = data
+            self._cache_ids.put(name)
+            if self._cache_ids.qsize() > self._max_cache_size:
+                self._cache.pop(self._cache_ids.get())