Author a storage provider

"""A minimal fictional storage provider: an in-memory content store.

Implements the ``Storage`` ABC — the text surface (``load`` / ``list`` /
``upload`` / ``delete`` / ``delete_dir``) — and registers as the process's single
provider. The binary methods (``load_bytes`` / ``upload_bytes`` / ``stat``) ship
text-bridging defaults, so this text-only backend satisfies the whole contract
with no extra code. A real backend swaps the dict for its own store.
"""

from tai42_contract.app import tai42_app
from tai42_contract.storage import Storage, assert_not_root


@tai42_app.storage.register_storage
class InMemoryStorage(Storage):
    def __init__(self) -> None:
        self._items: dict[str, str] = {}

    async def load(self, path: str) -> str:
        try:
            return self._items[path]
        except KeyError as exc:
            # The manager relies on this exact type to map a missing item to
            # Jinja's ``TemplateNotFound`` — never return an empty string.
            raise FileNotFoundError(path) from exc

    async def list(self) -> list[str]:
        return sorted(self._items)

    async def upload(self, path: str, content: str) -> None:
        self._items[path] = content

    async def delete(self, path: str) -> None:
        self._items.pop(path, None)

    async def delete_dir(self, path: str) -> None:
        # Refuse a delete that resolves to the storage root before touching keys.
        assert_not_root(path)
        prefix = path.rstrip("/") + "/"
        for key in [k for k in self._items if k.startswith(prefix)]:
            del self._items[key]

storage_module: your_package.storage