simple-module-file-storage 0.0.1__tar.gz

simple_module_file_storage-0.0.1/.gitignore

@@ -0,0 +1,59 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+*.egg
+
+# UV
+uv.lock
+
+# Node
+node_modules/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Environment
+.env
+
+# Database
+*.db
+*.sqlite3
+
+# Module-managed runtime state (e.g. uploaded dataset files,
+# default storage_dir for SM_DATASETS_STORAGE_DIR).
+var/
+
+# file_storage filesystem backend default root (override via SM_FILE_STORAGE_FS_ROOT_PATH).
+uploads/
+
+# Vite
+host/static/dist/
+
+# Auto-generated frontend module manifest (regenerated by the host at boot
+# or via `make gen-pages`).
+host/client_app/modules.manifest.json
+host/client_app/modules.generated.ts
+host/client_app/modules.generated.css
+
+# Worktrees
+.worktrees/
+
+# Performance profiles
+.memray/
+.benchmarks/
+
+# OS
+.DS_Store
+Thumbs.db
+
+.playwright-cli/*
+.playwright-mcp/*
+host/client_app/.playwright-cli/*
+.superpowers/

simple_module_file_storage-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anto Subash
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

simple_module_file_storage-0.0.1/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: simple_module_file_storage
+Version: 0.0.1
+Summary: Pluggable file upload + storage (local or S3 via extras) module for simple_module apps
+Project-URL: Homepage, https://github.com/antosubash/simple_module_python
+Project-URL: Repository, https://github.com/antosubash/simple_module_python
+Project-URL: Issues, https://github.com/antosubash/simple_module_python/issues
+Project-URL: Changelog, https://github.com/antosubash/simple_module_python/blob/main/CHANGELOG.md
+Author-email: Anto Subash <antosubash@live.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: file-upload,s3,simple-module,storage
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: aiofiles>=23
+Requires-Dist: simple-module-core==0.0.1
+Requires-Dist: simple-module-db==0.0.1
+Requires-Dist: simple-module-hosting==0.0.1
+Provides-Extra: s3
+Requires-Dist: aioboto3>=13; extra == 's3'
+Description-Content-Type: text/markdown
+
+# simple_module_file_storage
+
+Pluggable file-upload + storage module for [simple_module](https://github.com/antosubash/simple_module_python) apps. Defaults to local-disk storage for development; install the `[s3]` extra to switch to any S3-compatible backend via `aioboto3`.
+
+## Install
+
+```bash
+# local-disk storage (dev default)
+pip install simple_module_file_storage
+
+# S3-compatible storage (production)
+pip install "simple_module_file_storage[s3]"
+```
+
+## What it provides
+
+- `POST /api/files` upload endpoint with multipart + metadata.
+- `GET /api/files/{id}` signed-URL or stream download.
+- Pluggable backend via `SM_FILE_STORAGE_BACKEND` (`local` | `s3`).
+- S3 config via `SM_FILE_STORAGE_S3_BUCKET`, `SM_FILE_STORAGE_S3_ENDPOINT` (for R2/MinIO/etc.), `SM_FILE_STORAGE_S3_REGION`.
+
+## Usage
+
+From another module:
+
+```python
+from file_storage.service import FileStorageService   # type: ignore[import-not-found]
+
+async def attach_receipt(
+    svc: FileStorageService = Depends(FileStorageService),
+    upload: UploadFile = File(...),
+):
+    record = await svc.save(upload, folder="receipts/")
+    return {"file_id": record.id, "url": record.url}
+```
+
+Env config (example, S3):
+
+```
+SM_FILE_STORAGE_BACKEND=s3
+SM_FILE_STORAGE_S3_BUCKET=my-app-uploads
+SM_FILE_STORAGE_S3_REGION=us-east-1
+AWS_ACCESS_KEY_ID=...
+AWS_SECRET_ACCESS_KEY=...
+```
+
+## Depends on
+
+- `simple_module_core`, `simple_module_db`, `simple_module_hosting`
+- `aiofiles`
+- Optional: `aioboto3` (install the `[s3]` extra)
+
+## License
+
+MIT — see [LICENSE](https://github.com/antosubash/simple_module_python/blob/main/LICENSE).

simple_module_file_storage-0.0.1/README.md

@@ -0,0 +1,55 @@
+# simple_module_file_storage
+
+Pluggable file-upload + storage module for [simple_module](https://github.com/antosubash/simple_module_python) apps. Defaults to local-disk storage for development; install the `[s3]` extra to switch to any S3-compatible backend via `aioboto3`.
+
+## Install
+
+```bash
+# local-disk storage (dev default)
+pip install simple_module_file_storage
+
+# S3-compatible storage (production)
+pip install "simple_module_file_storage[s3]"
+```
+
+## What it provides
+
+- `POST /api/files` upload endpoint with multipart + metadata.
+- `GET /api/files/{id}` signed-URL or stream download.
+- Pluggable backend via `SM_FILE_STORAGE_BACKEND` (`local` | `s3`).
+- S3 config via `SM_FILE_STORAGE_S3_BUCKET`, `SM_FILE_STORAGE_S3_ENDPOINT` (for R2/MinIO/etc.), `SM_FILE_STORAGE_S3_REGION`.
+
+## Usage
+
+From another module:
+
+```python
+from file_storage.service import FileStorageService   # type: ignore[import-not-found]
+
+async def attach_receipt(
+    svc: FileStorageService = Depends(FileStorageService),
+    upload: UploadFile = File(...),
+):
+    record = await svc.save(upload, folder="receipts/")
+    return {"file_id": record.id, "url": record.url}
+```
+
+Env config (example, S3):
+
+```
+SM_FILE_STORAGE_BACKEND=s3
+SM_FILE_STORAGE_S3_BUCKET=my-app-uploads
+SM_FILE_STORAGE_S3_REGION=us-east-1
+AWS_ACCESS_KEY_ID=...
+AWS_SECRET_ACCESS_KEY=...
+```
+
+## Depends on
+
+- `simple_module_core`, `simple_module_db`, `simple_module_hosting`
+- `aiofiles`
+- Optional: `aioboto3` (install the `[s3]` extra)
+
+## License
+
+MIT — see [LICENSE](https://github.com/antosubash/simple_module_python/blob/main/LICENSE).

simple_module_file_storage-0.0.1/file_storage/__init__.py

@@ -0,0 +1 @@
+"""FileStorage module."""

simple_module_file_storage-0.0.1/file_storage/backends/__init__.py

@@ -0,0 +1,77 @@
+"""Storage backend registry — extension point for storage providers.
+
+Built-in providers (filesystem, S3) self-register on import. Third-party
+packages add new providers via :func:`register_backend`::
+
+    from file_storage.backends import register_backend
+    from file_storage.contracts.service import StorageBackend
+
+    @register_backend("azure_blob")
+    def _build(settings) -> StorageBackend:
+        return AzureBlobBackend(...)
+
+The factory receives the parsed :class:`FileStorageSettings` so providers
+can read their own ``SM_FILE_STORAGE_*`` keys (or extend the settings
+class with extra fields). :func:`build_backend` resolves the active
+factory by ``settings.backend`` and raises :class:`ConfigurationError`
+on an unknown id, listing all currently registered providers.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from file_storage.contracts.service import ConfigurationError
+
+if TYPE_CHECKING:
+    from file_storage.contracts.service import StorageBackend
+    from file_storage.settings import FileStorageSettings
+
+BackendFactory = Callable[["FileStorageSettings"], "StorageBackend"]
+
+_REGISTRY: dict[str, BackendFactory] = {}
+
+
+def register_backend(backend_id: str) -> Callable[[BackendFactory], BackendFactory]:
+    """Decorator that registers a factory under ``backend_id``."""
+
+    def decorator(factory: BackendFactory) -> BackendFactory:
+        _REGISTRY[backend_id] = factory
+        return factory
+
+    return decorator
+
+
+def unregister_backend(backend_id: str) -> None:
+    """Remove a registered backend. Primarily for tests."""
+    _REGISTRY.pop(backend_id, None)
+
+
+def registered_backends() -> list[str]:
+    """Return all currently registered backend ids, sorted."""
+    return sorted(_REGISTRY)
+
+
+def build_backend(settings: FileStorageSettings) -> StorageBackend:
+    """Construct the backend selected by ``settings.backend``."""
+    factory = _REGISTRY.get(settings.backend)
+    if factory is None:
+        raise ConfigurationError(
+            f"Unknown storage backend {settings.backend!r}. Registered: {registered_backends()}."
+        )
+    return factory(settings)
+
+
+# Trigger self-registration of built-in providers. Order is irrelevant; both
+# add themselves to the same module-global registry.
+from file_storage.backends import filesystem as _filesystem  # noqa: E402,F401
+from file_storage.backends import s3 as _s3  # noqa: E402,F401
+
+__all__ = [
+    "BackendFactory",
+    "build_backend",
+    "register_backend",
+    "registered_backends",
+    "unregister_backend",
+]

simple_module_file_storage-0.0.1/file_storage/backends/filesystem.py

@@ -0,0 +1,84 @@
+"""Filesystem storage backend — writes objects under a configurable root."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from pathlib import Path
+
+import aiofiles
+
+from file_storage import constants
+from file_storage.backends import register_backend
+from file_storage.contracts.service import (
+    NotSupportedError,
+    StorageBackendError,
+    StorageNotFoundError,
+)
+from file_storage.settings import FileStorageSettings
+
+
+class FilesystemBackend:
+    """Stores objects on the local filesystem under ``root``.
+
+    Keys are sharded by their first two characters to keep any single
+    directory from accumulating millions of entries (which slows ``readdir``
+    on most filesystems). A key like ``2026/04/19/abc123.png`` is written to
+    ``<root>/20/2026/04/19/abc123.png``.
+    """
+
+    backend_id = constants.BackendId.FILESYSTEM
+    supports_presigned_url = False
+
+    def __init__(self, root: Path) -> None:
+        self.root = root
+
+    def _resolve(self, key: str) -> Path:
+        # Reject path traversal: ".." segments and absolute paths can escape root.
+        if key.startswith("/") or ".." in Path(key).parts:
+            raise StorageBackendError(f"Invalid storage key: {key!r}")
+        shard = key[:2] if len(key) >= 2 else "_"
+        return self.root / shard / key
+
+    async def put(
+        self,
+        key: str,
+        stream: AsyncIterator[bytes],
+        *,
+        content_type: str,
+        size: int,
+    ) -> None:
+        path = self._resolve(key)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        async with aiofiles.open(path, "wb") as fh:
+            async for chunk in stream:
+                await fh.write(chunk)
+
+    async def get(self, key: str) -> AsyncIterator[bytes]:
+        path = self._resolve(key)
+        if not path.exists():
+            raise StorageNotFoundError(key)
+        return _stream_file(path)
+
+    async def delete(self, key: str) -> None:
+        path = self._resolve(key)
+        path.unlink(missing_ok=True)
+
+    async def exists(self, key: str) -> bool:
+        return self._resolve(key).exists()
+
+    async def presigned_get_url(self, key: str, ttl_seconds: int) -> str:
+        raise NotSupportedError("Filesystem backend cannot mint presigned URLs.")
+
+
+async def _stream_file(path: Path) -> AsyncIterator[bytes]:
+    async with aiofiles.open(path, "rb") as fh:
+        while True:
+            chunk = await fh.read(constants.DEFAULT_CHUNK_SIZE)
+            if not chunk:
+                break
+            yield chunk
+
+
+@register_backend(constants.BackendId.FILESYSTEM)
+def _build(settings: FileStorageSettings) -> FilesystemBackend:
+    return FilesystemBackend(root=settings.resolved_fs_root())

simple_module_file_storage-0.0.1/file_storage/backends/s3.py

@@ -0,0 +1,156 @@
+"""S3-compatible storage backend (AWS S3, MinIO, Cloudflare R2, ...).
+
+``aioboto3`` is imported lazily at backend construction so the module loads
+even when the optional S3 extra isn't installed; the failure mode is a clear
+:class:`ConfigurationError` at boot rather than a confusing import error.
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from tempfile import SpooledTemporaryFile
+from typing import TYPE_CHECKING, Any
+
+from file_storage import constants
+from file_storage.backends import register_backend
+from file_storage.contracts.service import (
+    ConfigurationError,
+    StorageBackendError,
+    StorageNotFoundError,
+)
+from file_storage.settings import FileStorageSettings
+
+if TYPE_CHECKING:
+    pass
+
+
+class S3Backend:
+    """S3-compatible object storage.
+
+    Each operation opens a fresh ``aioboto3`` client context (cheap; the
+    underlying ``aiobotocore`` session is reused via ``self._session``). We
+    deliberately do not hold one long-lived client across requests because
+    aioboto3 client contexts are per-event-loop and tests run multiple loops.
+    """
+
+    backend_id = constants.BackendId.S3
+    supports_presigned_url = True
+
+    def __init__(self, *, bucket: str, region: str, client_kwargs: dict[str, Any]) -> None:
+        try:
+            import aioboto3
+        except ImportError as exc:
+            raise ConfigurationError(
+                "S3 backend requires the 'aioboto3' package. "
+                "Install with: uv add --optional s3 aioboto3"
+            ) from exc
+        self._aioboto3 = aioboto3
+        self._session = aioboto3.Session()
+        self.bucket = bucket
+        self.region = region
+        self.client_kwargs = client_kwargs
+
+    def _client(self):
+        return self._session.client("s3", **self.client_kwargs)
+
+    async def put(
+        self,
+        key: str,
+        stream: AsyncIterator[bytes],
+        *,
+        content_type: str,
+        size: int,
+    ) -> None:
+        # Spool to memory up to SPOOL_MAX_SIZE_BYTES, then to a temp file.
+        # put_object needs a seekable file-like; multipart upload would be
+        # the next step for very large files (deferred to v2).
+        with SpooledTemporaryFile(max_size=constants.SPOOL_MAX_SIZE_BYTES) as buf:
+            async for chunk in stream:
+                buf.write(chunk)
+            length = buf.tell()
+            buf.seek(0)
+            try:
+                async with self._client() as client:
+                    await client.put_object(
+                        Bucket=self.bucket,
+                        Key=key,
+                        Body=buf,
+                        ContentType=content_type,
+                        ContentLength=length,
+                    )
+            except Exception as exc:
+                raise StorageBackendError(f"S3 put_object failed: {exc}") from exc
+
+    async def get(self, key: str) -> AsyncIterator[bytes]:
+        try:
+            async with self._client() as client:
+                resp = await client.get_object(Bucket=self.bucket, Key=key)
+                # ``Body.read()`` works uniformly across aioboto3 (real) and
+                # moto's patched aiobotocore (tests); ``iter_chunks`` is sync
+                # under moto, breaking ``async for``.
+                data = await resp["Body"].read()
+        except Exception as exc:
+            if _is_not_found(exc):
+                raise StorageNotFoundError(key) from exc
+            raise StorageBackendError(f"S3 get_object failed: {exc}") from exc
+
+        for offset in range(0, len(data), constants.DEFAULT_CHUNK_SIZE):
+            yield data[offset : offset + constants.DEFAULT_CHUNK_SIZE]
+
+    async def delete(self, key: str) -> None:
+        try:
+            async with self._client() as client:
+                await client.delete_object(Bucket=self.bucket, Key=key)
+        except Exception as exc:
+            raise StorageBackendError(f"S3 delete_object failed: {exc}") from exc
+
+    async def exists(self, key: str) -> bool:
+        try:
+            async with self._client() as client:
+                await client.head_object(Bucket=self.bucket, Key=key)
+                return True
+        except Exception as exc:
+            if _is_not_found(exc):
+                return False
+            raise StorageBackendError(f"S3 head_object failed: {exc}") from exc
+
+    async def presigned_get_url(self, key: str, ttl_seconds: int) -> str:
+        try:
+            async with self._client() as client:
+                return await client.generate_presigned_url(
+                    "get_object",
+                    Params={"Bucket": self.bucket, "Key": key},
+                    ExpiresIn=ttl_seconds,
+                )
+        except Exception as exc:
+            raise StorageBackendError(f"presign failed: {exc}") from exc
+
+
+def _is_not_found(exc: Exception) -> bool:
+    """Detect a 404 from botocore's heterogeneous error shapes."""
+    response = getattr(exc, "response", None)
+    if isinstance(response, dict):
+        code = response.get("Error", {}).get("Code")
+        if code in {"NoSuchKey", "404", "NotFound"}:
+            return True
+    return getattr(exc, "__class__", type(exc)).__name__ in {
+        "NoSuchKey",
+        "ClientError",
+    } and "404" in str(exc)
+
+
+@register_backend(constants.BackendId.S3)
+def _build(settings: FileStorageSettings) -> S3Backend:
+    if not settings.s3_bucket or not settings.s3_region:
+        raise ConfigurationError("S3 backend requires s3_bucket and s3_region.")
+    client_kwargs: dict[str, Any] = {"region_name": settings.s3_region}
+    if settings.s3_endpoint_url:
+        client_kwargs["endpoint_url"] = settings.s3_endpoint_url
+    if settings.s3_access_key_id and settings.s3_secret_access_key:
+        client_kwargs["aws_access_key_id"] = settings.s3_access_key_id
+        client_kwargs["aws_secret_access_key"] = settings.s3_secret_access_key
+    return S3Backend(
+        bucket=settings.s3_bucket,
+        region=settings.s3_region,
+        client_kwargs=client_kwargs,
+    )

simple_module_file_storage-0.0.1/file_storage/constants.py

@@ -0,0 +1,107 @@
+"""Single source of truth for every literal in the file_storage module.
+
+Permissions, event topics, route prefixes, env-var prefix, page names, table
+names, error codes, default config values — all live here. Other files in the
+module import from this one rather than embedding string literals, so renames
+stay localised and `rg` can prove there are no magic strings outside of this
+file.
+"""
+
+from __future__ import annotations
+
+from typing import Final
+
+# ── Module identity ──────────────────────────────────────────────────
+# ``MODULE_NAME`` is the snake_case package name; ``MODULE_PASCAL`` matches the
+# Inertia page-prefix convention (PascalCase of the module dir). ``meta.name``
+# uses ``MODULE_PASCAL`` so the diagnostic code SM003 lines up against
+# ``FileStorage/Browse.tsx``. ``MODULE_DISPLAY_NAME`` is the user-visible label
+# (menu, permission group) — keep it free-form.
+MODULE_NAME: Final = "file_storage"
+MODULE_PASCAL: Final = "FileStorage"
+MODULE_DISPLAY_NAME: Final = "Files"
+
+# ── Configuration ────────────────────────────────────────────────────
+ENV_PREFIX: Final = "SM_FILE_STORAGE_"
+
+# ── Routing ──────────────────────────────────────────────────────────
+ROUTE_PREFIX_API: Final = "/api/file-storage"
+ROUTE_PREFIX_VIEW: Final = "/file-storage"
+
+# REST sub-paths (joined to ROUTE_PREFIX_API by the router)
+PATH_UPLOAD: Final = "/upload"
+PATH_FILES: Final = "/files"
+PATH_FILE_BY_ID: Final = "/files/{file_id}"
+PATH_FILE_DOWNLOAD: Final = "/files/{file_id}/download"
+
+# ── Inertia page names ───────────────────────────────────────────────
+PAGE_BROWSE: Final = "FileStorage/Browse"
+
+# ── Database ─────────────────────────────────────────────────────────
+SCHEMA_NAME: Final = "file_storage"
+TABLE_STORED_FILE: Final = "file_storage_stored_file"
+
+# ── i18n ─────────────────────────────────────────────────────────────
+LOCALE_NAMESPACE: Final = MODULE_NAME
+
+
+class BackendId:
+    """Stable identifiers for built-in storage providers.
+
+    Third-party providers register themselves under any string id, but the
+    built-ins are referenced from settings, the model, and tests, so they
+    deserve named constants.
+    """
+
+    FILESYSTEM: Final = "filesystem"
+    S3: Final = "s3"
+
+
+class Permission:
+    UPLOAD: Final = "file_storage.upload"
+    DOWNLOAD: Final = "file_storage.download"
+    DELETE: Final = "file_storage.delete"
+    MANAGE: Final = "file_storage.manage"
+
+
+class Event:
+    FILE_UPLOADED: Final = "file_storage.file.uploaded"
+    FILE_DELETED: Final = "file_storage.file.deleted"
+
+
+class FeatureFlag:
+    PUBLIC_UPLOADS: Final = "file_storage.public_uploads"
+
+
+class ErrorCode:
+    """Machine-readable codes returned in 4xx response bodies."""
+
+    TOO_LARGE: Final = "file_storage.too_large"
+    BAD_TYPE: Final = "file_storage.bad_type"
+    NOT_FOUND: Final = "file_storage.not_found"
+    BACKEND_ERROR: Final = "file_storage.backend_error"
+
+
+class I18nKey:
+    """Translator keys (full dotted paths). Mirror locales/en.json shape."""
+
+    ERR_NOT_FOUND: Final = "file_storage.errors.not_found"
+    ERR_TOO_LARGE: Final = "file_storage.errors.too_large"
+    ERR_BAD_TYPE: Final = "file_storage.errors.bad_type"
+    ERR_BACKEND: Final = "file_storage.errors.backend_error"
+
+
+# ── Defaults ─────────────────────────────────────────────────────────
+DEFAULT_BACKEND: Final = BackendId.FILESYSTEM
+DEFAULT_FS_ROOT: Final = "./uploads"
+DEFAULT_MAX_FILE_SIZE_BYTES: Final = 100 * 1024 * 1024  # 100 MB
+DEFAULT_PRESIGN_TTL_SECONDS: Final = 300  # 5 minutes
+DEFAULT_CHUNK_SIZE: Final = 64 * 1024  # 64 KB
+SPOOL_MAX_SIZE_BYTES: Final = 10 * 1024 * 1024  # 10 MB before disk-spill
+
+# ── Menu ─────────────────────────────────────────────────────────────
+MENU_ICON: Final = "files"
+MENU_ORDER: Final = 40
+MENU_ROLES: Final = ("admin",)
+ADMIN_ROLE: Final = "admin"
+USER_ROLE: Final = "user"

simple_module_file_storage-0.0.1/file_storage/contracts/__init__.py

@@ -0,0 +1,25 @@
+"""file_storage contracts — public interface for other modules."""
+
+from file_storage.contracts.events import FileDeleted, FileUploaded
+from file_storage.contracts.schemas import StoredFileListOut, StoredFileOut
+from file_storage.contracts.service import (
+    ConfigurationError,
+    NotSupportedError,
+    StorageBackend,
+    StorageBackendError,
+    StorageError,
+    StorageNotFoundError,
+)
+
+__all__ = [
+    "ConfigurationError",
+    "FileDeleted",
+    "FileUploaded",
+    "NotSupportedError",
+    "StorageBackend",
+    "StorageBackendError",
+    "StorageError",
+    "StorageNotFoundError",
+    "StoredFileListOut",
+    "StoredFileOut",
+]