fapilot 0.1.0__py3-none-any.whl

fapilot/__init__.py

@@ -0,0 +1,5 @@
+from fapilot.core.application import Fapilot, create_app
+
+__version__ = "0.1.0"
+
+__all__ = ["Fapilot", "__version__", "create_app"]

fapilot/apps/__init__.py

@@ -0,0 +1,5 @@
+from fapilot.apps.config import AppConfig
+from fapilot.apps.registry import AppRegistry
+
+__all__ = ["AppConfig", "AppRegistry"]
+

fapilot/apps/config.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from fastapi import APIRouter
+
+
+@dataclass(slots=True)
+class AppConfig:
+    name: str
+    label: str | None = None
+    verbose_name: str | None = None
+    router: APIRouter | None = None
+    router_prefix: str | None = None
+    tortoise_models: list[str] = field(default_factory=list)
+    migrations_package: str | None = None
+
+    def ready(self) -> None:
+        """Hook called after every app is imported and registered."""
+
+    @property
+    def app_label(self) -> str:
+        return self.label or self.name.rsplit(".", 1)[-1]
+
+    def as_tortoise_app(self) -> dict[str, Any]:
+        models = [*self.tortoise_models]
+        if self.migrations_package is not None:
+            models.append(self.migrations_package)
+        return {"models": models, "default_connection": "default"}
+

fapilot/apps/registry.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from importlib import import_module
+
+from fapilot.apps.config import AppConfig
+
+
+class AppRegistry:
+    def __init__(self) -> None:
+        self._apps: dict[str, AppConfig] = {}
+        self.ready = False
+
+    def populate(self, installed_apps: Iterable[str]) -> None:
+        if self.ready:
+            return
+        for dotted_path in installed_apps:
+            app_config = self._load_config(dotted_path)
+            label = app_config.app_label
+            if label in self._apps:
+                raise RuntimeError(f"Duplicate app label: {label}")
+            self._apps[label] = app_config
+        for app_config in self._apps.values():
+            app_config.ready()
+        self.ready = True
+
+    def get_app(self, label: str) -> AppConfig:
+        return self._apps[label]
+
+    def get_apps(self) -> list[AppConfig]:
+        return list(self._apps.values())
+
+    def _load_config(self, dotted_path: str) -> AppConfig:
+        module_path, _, class_name = dotted_path.rpartition(".")
+        if not module_path:
+            module_path = f"{dotted_path}.apps"
+            class_name = "Config"
+        module = import_module(module_path)
+        config_cls = getattr(module, class_name)
+        config = config_cls()
+        if not isinstance(config, AppConfig):
+            raise TypeError(f"{dotted_path} must instantiate fapilot.apps.AppConfig")
+        return config

fapilot/auth/__init__.py

@@ -0,0 +1,5 @@
+from fapilot.auth.jwt import create_access_token, decode_access_token
+from fapilot.auth.passwords import hash_password, verify_password
+
+__all__ = ["create_access_token", "decode_access_token", "hash_password", "verify_password"]
+

fapilot/auth/jwt.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+from jose import JWTError, jwt
+
+from fapilot.conf import get_settings
+
+
+def create_access_token(subject: str, claims: dict[str, Any] | None = None) -> str:
+    settings = get_settings()
+    jwt_settings = settings.JWT_SETTINGS
+    expires_at = datetime.now(UTC) + timedelta(minutes=jwt_settings.access_token_expire_minutes)
+    payload = {
+        "sub": subject,
+        "iss": jwt_settings.issuer,
+        "exp": expires_at,
+        **(claims or {}),
+    }
+    return jwt.encode(payload, settings.SECRET_KEY, algorithm=jwt_settings.algorithm)
+
+
+def decode_access_token(token: str) -> dict[str, Any] | None:
+    settings = get_settings()
+    try:
+        return jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.JWT_SETTINGS.algorithm])
+    except JWTError:
+        return None
+

fapilot/auth/passwords.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from passlib.context import CryptContext
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+def hash_password(password: str) -> str:
+    return pwd_context.hash(password)
+
+
+def verify_password(password: str, hashed_password: str) -> bool:
+    return pwd_context.verify(password, hashed_password)
+

fapilot/background/__init__.py

@@ -0,0 +1,4 @@
+from fapilot.background.tasks import TaskQueue
+
+__all__ = ["TaskQueue"]
+

fapilot/background/tasks.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+
+class TaskQueue:
+    def spawn(
+        self,
+        func: Callable[..., Coroutine[Any, Any, Any]],
+        *args: Any,
+        **kwargs: Any,
+    ) -> asyncio.Task:
+        return asyncio.create_task(func(*args, **kwargs))

fapilot/cli.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import argparse
+import subprocess
+from pathlib import Path
+
+from fapilot.db.migrations import AerichMigrationBackend
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="fapilot")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    startproject = subparsers.add_parser("startproject")
+    startproject.add_argument("name")
+    startapp = subparsers.add_parser("startapp")
+    startapp.add_argument("name")
+    makemigrations = subparsers.add_parser("makemigrations")
+    makemigrations.add_argument("--name")
+    subparsers.add_parser("migrate")
+    runserver = subparsers.add_parser("runserver")
+    runserver.add_argument("--host", default="127.0.0.1")
+    runserver.add_argument("--port", default="8000")
+    args = parser.parse_args()
+
+    if args.command == "startproject":
+        start_project(args.name)
+    elif args.command == "startapp":
+        start_app(args.name)
+    elif args.command == "makemigrations":
+        AerichMigrationBackend().makemigrations(args.name)
+    elif args.command == "migrate":
+        AerichMigrationBackend().migrate()
+    elif args.command == "runserver":
+        subprocess.run(
+            ["uvicorn", "config.asgi:app", "--host", args.host, "--port", args.port, "--reload"],
+            check=True,
+        )
+
+
+def start_project(name: str) -> None:
+    root = Path(name)
+    root.mkdir()
+    for directory in ["config", "apps", "common", "tests"]:
+        (root / directory).mkdir()
+        (root / directory / "__init__.py").write_text("", encoding="utf-8")
+    _write(root / "manage.py", MANAGE)
+    _write(root / "config/settings.py", SETTINGS)
+    _write(root / "config/database.py", DATABASE)
+    _write(root / "config/urls.py", URLS)
+    _write(root / "config/asgi.py", ASGI)
+    _write(root / "config/logging.py", "LOGGING = {}\n")
+    _write(root / "common/crud.py", "from fapilot.crud import CRUDRouterService\n")
+    _write(root / "common/pagination.py", "from fapilot.pagination import Page, Pagination\n")
+    _write(root / "common/filtering.py", "from fapilot.filtering import pick_filters\n")
+    _write(root / "common/exceptions.py", "from fapilot.exceptions import FapilotError\n")
+    _write(
+        root / "common/permissions.py",
+        "from fapilot.permissions import AllowAny, IsAuthenticated\n",
+    )
+    _write(root / "common/middleware.py", "from fapilot.middleware import install_cors\n")
+    _write(root / "common/responses.py", "from fapilot.responses import ok\n")
+    _write(root / "common/events.py", "from fapilot.events import SignalDispatcher\n")
+    _write(root / "common/models.py", "from tortoise import fields, models\n")
+    _write(root / "common/schemas.py", "from pydantic import BaseModel, ConfigDict\n")
+    _write(root / "common/utils.py", "\n")
+    _write(root / ".env", ENV)
+    _write(root / ".env.example", ENV)
+    _write(root / ".gitignore", GITIGNORE)
+    _write(root / "README.md", PROJECT_README.format(name=name))
+    _write(root / "Dockerfile", DOCKERFILE)
+    _write(root / "docker-compose.yml", COMPOSE)
+    _write(root / "pyproject.toml", PROJECT_PYPROJECT.format(name=name))
+
+
+def start_app(name: str) -> None:
+    app_dir = Path("apps") / name
+    app_dir.mkdir(parents=True)
+    (app_dir / "tests").mkdir()
+    (app_dir / "migrations").mkdir()
+    for file_name, content in APP_FILES.items():
+        class_name = name.title().replace("_", "")
+        _write(app_dir / file_name, content.format(name=name, class_name=class_name))
+    _write(app_dir / "tests/__init__.py", "")
+    _write(app_dir / "migrations/__init__.py", "")
+
+
+def _write(path: Path, content: str) -> None:
+    path.write_text(content, encoding="utf-8")
+
+
+MANAGE = """#!/usr/bin/env python
+from fapilot.cli import main
+
+if __name__ == "__main__":
+    main()
+"""
+
+SETTINGS = '''from fapilot.conf import FapilotSettings
+
+DEBUG = True
+SECRET_KEY = "change-me"
+ALLOWED_HOSTS = ["localhost", "127.0.0.1"]
+DATABASE_URL = "sqlite://db.sqlite3"
+INSTALLED_APPS = []
+MIDDLEWARE = ["common.middleware.install_cors"]
+CORS_ALLOWED_ORIGINS = []
+TIME_ZONE = "UTC"
+LANGUAGE_CODE = "en-us"
+API_PREFIX = "/api"
+DEFAULT_PAGE_SIZE = 20
+MAX_PAGE_SIZE = 100
+AUTH_USER_MODEL = "users.User"
+JWT_SETTINGS = FapilotSettings().JWT_SETTINGS
+LOGGING = {}
+'''
+
+DATABASE = """import os
+
+from fapilot.apps import AppRegistry
+from fapilot.conf import load_settings
+from fapilot.db.tortoise import build_tortoise_config
+
+settings = load_settings("config.settings")
+registry = AppRegistry()
+registry.populate(settings.INSTALLED_APPS)
+TORTOISE_ORM = build_tortoise_config(settings, registry)
+"""
+
+URLS = """from fastapi import APIRouter
+
+router = APIRouter()
+"""
+
+ASGI = """import os
+
+from fapilot import create_app
+from fapilot.conf import load_settings
+
+os.environ.setdefault("FAPILOT_SETTINGS_MODULE", "config.settings")
+app = create_app(load_settings("config.settings"))
+"""
+
+ENV = """DEBUG=true
+SECRET_KEY=change-me
+DATABASE_URL=sqlite://db.sqlite3
+"""
+
+GITIGNORE = """.venv/
+__pycache__/
+.env
+db.sqlite3
+.ruff_cache/
+.pytest_cache/
+"""
+
+PROJECT_README = """# {name}
+
+Generated by Fapilot.
+
+```bash
+uv sync
+fapilot startapp users
+fapilot runserver
+```
+"""
+
+PROJECT_PYPROJECT = '''[project]
+name = "{name}"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = ["fapilot"]
+
+[tool.aerich]
+tortoise_orm = "config.database.TORTOISE_ORM"
+location = "./migrations"
+src_folder = "."
+'''
+
+DOCKERFILE = """FROM python:3.12-slim
+WORKDIR /app
+COPY . .
+RUN pip install fapilot
+CMD ["uvicorn", "config.asgi:app", "--host", "0.0.0.0", "--port", "8000"]
+"""
+
+COMPOSE = """services:
+  postgres:
+    image: postgres:16
+    environment:
+      POSTGRES_DB: app
+      POSTGRES_USER: app
+      POSTGRES_PASSWORD: app
+    ports:
+      - "5432:5432"
+"""
+
+APP_FILES = {
+    "__init__.py": "",
+    "apps.py": """from fapilot.apps import AppConfig
+
+
+class {class_name}Config(AppConfig):
+    def __init__(self) -> None:
+        super().__init__(name="apps.{name}", label="{name}")
+""",
+    "models.py": "from tortoise import fields, models\n\n\n# Define models here.\n",
+    "schemas.py": "from pydantic import BaseModel, ConfigDict\n\n\n# Define schemas here.\n",
+    "api.py": """from fastapi import APIRouter
+
+router = APIRouter()
+""",
+    "services.py": "",
+    "repositories.py": "",
+    "permissions.py": "from fapilot.permissions import AllowAny, IsAuthenticated\n",
+    "dependencies.py": "",
+    "signals.py": "",
+    "admin.py": "",
+}

fapilot/conf/__init__.py

@@ -0,0 +1,4 @@
+from fapilot.conf.settings import FapilotSettings, get_settings, load_settings
+
+__all__ = ["FapilotSettings", "get_settings", "load_settings"]
+

fapilot/conf/settings.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import importlib
+import os
+from functools import lru_cache
+from typing import Any
+
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class JWTSettings(BaseSettings):
+    algorithm: str = "HS256"
+    access_token_expire_minutes: int = 30
+    issuer: str = "fapilot"
+
+
+class FapilotSettings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_nested_delimiter="__",
+        extra="ignore",
+        case_sensitive=True,
+    )
+
+    DEBUG: bool = False
+    SECRET_KEY: str = Field(default="change-me")
+    ALLOWED_HOSTS: list[str] = Field(default_factory=lambda: ["localhost", "127.0.0.1"])
+    DATABASE_URL: str = "sqlite://db.sqlite3"
+    INSTALLED_APPS: list[str] = Field(default_factory=list)
+    MIDDLEWARE: list[str] = Field(default_factory=list)
+    CORS_ALLOWED_ORIGINS: list[str] = Field(default_factory=list)
+    TIME_ZONE: str = "UTC"
+    LANGUAGE_CODE: str = "en-us"
+    API_PREFIX: str = "/api"
+    DEFAULT_PAGE_SIZE: int = 20
+    MAX_PAGE_SIZE: int = 100
+    AUTH_USER_MODEL: str = "users.User"
+    JWT_SETTINGS: JWTSettings = Field(default_factory=JWTSettings)
+    LOGGING: dict[str, Any] = Field(default_factory=dict)
+
+    @field_validator("DEBUG", mode="before")
+    @classmethod
+    def parse_debug(cls, value: Any) -> Any:
+        if isinstance(value, str) and value.lower() in {"release", "prod", "production"}:
+            return False
+        return value
+
+
+def load_settings(settings_module: str | None = None) -> FapilotSettings:
+    module_name = settings_module or os.getenv("FAPILOT_SETTINGS_MODULE")
+    if module_name is None:
+        return FapilotSettings()
+    module = importlib.import_module(module_name)
+    values = {
+        key: getattr(module, key)
+        for key in dir(module)
+        if key.isupper() and not key.startswith("_")
+    }
+    return FapilotSettings(**values)
+
+
+@lru_cache
+def get_settings() -> FapilotSettings:
+    return load_settings()

fapilot/core/application.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Callable
+from contextlib import asynccontextmanager
+from importlib import import_module
+
+from fastapi import FastAPI
+
+from fapilot.apps import AppRegistry
+from fapilot.conf import FapilotSettings, get_settings
+from fapilot.db.tortoise import close_orm, init_orm
+from fapilot.events.dispatcher import SignalDispatcher
+
+
+class Fapilot:
+    def __init__(self, settings: FapilotSettings | None = None) -> None:
+        self.settings = settings or get_settings()
+        self.registry = AppRegistry()
+        self.events = SignalDispatcher()
+
+    def setup(self) -> None:
+        self.registry.populate(self.settings.INSTALLED_APPS)
+
+    def create_fastapi(self) -> FastAPI:
+        self.setup()
+
+        @asynccontextmanager
+        async def lifespan(app: FastAPI) -> AsyncIterator[None]:
+            app.state.fapilot = self
+            await init_orm(self.settings, self.registry)
+            await self.events.emit("startup", app=app)
+            try:
+                yield
+            finally:
+                await self.events.emit("shutdown", app=app)
+                await close_orm()
+
+        app = FastAPI(debug=self.settings.DEBUG, lifespan=lifespan)
+        app.state.fapilot = self
+        self._install_middleware(app)
+        self._include_app_routers(app)
+        return app
+
+    def _install_middleware(self, app: FastAPI) -> None:
+        for dotted_path in self.settings.MIDDLEWARE:
+            factory = import_string(dotted_path)
+            factory(app)
+
+    def _include_app_routers(self, app: FastAPI) -> None:
+        for app_config in self.registry.get_apps():
+            router = app_config.router
+            if router is None:
+                try:
+                    api_module = import_module(f"{app_config.name}.api")
+                except ModuleNotFoundError:
+                    continue
+                router = getattr(api_module, "router", None)
+            if router is not None:
+                prefix = (
+                    app_config.router_prefix
+                    or f"{self.settings.API_PREFIX}/{app_config.app_label}"
+                )
+                app.include_router(router, prefix=prefix, tags=[app_config.app_label])
+
+
+def import_string(dotted_path: str) -> Callable:
+    module_path, _, attribute = dotted_path.rpartition(".")
+    if not module_path:
+        raise ImportError(f"{dotted_path!r} is not a dotted import path")
+    module = import_module(module_path)
+    return getattr(module, attribute)
+
+
+def create_app(settings: FapilotSettings | None = None) -> FastAPI:
+    return Fapilot(settings=settings).create_fastapi()

fapilot/crud.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Any, Generic, TypeVar
+
+from pydantic import BaseModel
+from tortoise.models import Model
+
+ModelT = TypeVar("ModelT", bound=Model)
+CreateSchemaT = TypeVar("CreateSchemaT", bound=BaseModel)
+UpdateSchemaT = TypeVar("UpdateSchemaT", bound=BaseModel)
+
+
+class CRUDRouterService(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
+    def __init__(self, model: type[ModelT]) -> None:
+        self.model = model
+
+    async def list(
+        self,
+        *,
+        offset: int = 0,
+        limit: int = 20,
+        filters: dict[str, Any] | None = None,
+    ):
+        queryset = self.model.filter(**(filters or {}))
+        return await queryset.offset(offset).limit(limit)
+
+    async def count(self, filters: dict[str, Any] | None = None) -> int:
+        return await self.model.filter(**(filters or {})).count()
+
+    async def get(self, object_id: Any) -> ModelT | None:
+        return await self.model.get_or_none(id=object_id)
+
+    async def create(self, data: CreateSchemaT) -> ModelT:
+        return await self.model.create(**data.model_dump())
+
+    async def update(self, instance: ModelT, data: UpdateSchemaT) -> ModelT:
+        for key, value in data.model_dump(exclude_unset=True).items():
+            setattr(instance, key, value)
+        await instance.save()
+        return instance
+
+    async def delete(self, instance: ModelT) -> None:
+        await instance.delete()

fapilot/db/__init__.py

@@ -0,0 +1,4 @@
+from fapilot.db.migrations import AerichMigrationBackend, MigrationBackend
+
+__all__ = ["AerichMigrationBackend", "MigrationBackend"]
+

fapilot/db/migrations.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import subprocess
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+class MigrationBackend(ABC):
+    @abstractmethod
+    def init(self) -> None: ...
+
+    @abstractmethod
+    def makemigrations(self, name: str | None = None) -> None: ...
+
+    @abstractmethod
+    def migrate(self) -> None: ...
+
+
+@dataclass(slots=True)
+class AerichMigrationBackend(MigrationBackend):
+    config: str = "pyproject.toml"
+    app: str = "models"
+    tortoise_config_path: str = "config.database.TORTOISE_ORM"
+
+    def init(self) -> None:
+        self._run("init", "-t", self.tortoise_config_path)
+
+    def makemigrations(self, name: str | None = None) -> None:
+        args = ["migrate"]
+        if name:
+            args.extend(["--name", name])
+        self._run(*args)
+
+    def migrate(self) -> None:
+        self._run("upgrade")
+
+    def _run(self, *args: str) -> None:
+        subprocess.run(
+            ["aerich", "-c", self.config, "--app", self.app, *args],
+            check=True,
+        )
+

fapilot/db/tortoise.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from tortoise import Tortoise
+
+from fapilot.apps import AppRegistry
+from fapilot.conf import FapilotSettings
+
+
+def build_tortoise_config(settings: FapilotSettings, registry: AppRegistry) -> dict:
+    apps: dict[str, dict] = {
+        "models": {"models": ["aerich.models"], "default_connection": "default"}
+    }
+    for app_config in registry.get_apps():
+        models = [f"{app_config.name}.models"]
+        models.extend(app_config.tortoise_models)
+        apps[app_config.app_label] = {"models": models, "default_connection": "default"}
+    return {"connections": {"default": settings.DATABASE_URL}, "apps": apps}
+
+
+async def init_orm(settings: FapilotSettings, registry: AppRegistry) -> None:
+    await Tortoise.init(config=build_tortoise_config(settings, registry))
+    if settings.DEBUG:
+        await Tortoise.generate_schemas(safe=True)
+
+
+async def close_orm() -> None:
+    await Tortoise.close_connections()
+

fapilot/events/__init__.py

@@ -0,0 +1,4 @@
+from fapilot.events.dispatcher import SignalDispatcher
+
+__all__ = ["SignalDispatcher"]
+

fapilot/events/dispatcher.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import inspect
+from collections import defaultdict
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+Receiver = Callable[..., Awaitable[None] | None]
+
+
+class SignalDispatcher:
+    def __init__(self) -> None:
+        self._receivers: dict[str, list[Receiver]] = defaultdict(list)
+
+    def connect(self, signal: str, receiver: Receiver) -> None:
+        self._receivers[signal].append(receiver)
+
+    async def emit(self, signal: str, **payload: Any) -> None:
+        for receiver in self._receivers.get(signal, []):
+            result = receiver(**payload)
+            if inspect.isawaitable(result):
+                await result
+

fapilot/exceptions.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+
+class FapilotError(Exception):
+    pass
+
+
+class ConfigurationError(FapilotError):
+    pass
+

fapilot/filtering.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def pick_filters(params: dict[str, Any], allowed: set[str]) -> dict[str, Any]:
+    return {key: value for key, value in params.items() if key in allowed and value is not None}
+

fapilot/management/__init__.py

@@ -0,0 +1 @@
+

fapilot/management/commands.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+
+
+class CommandRegistry:
+    def __init__(self) -> None:
+        self._commands: dict[str, Callable[..., None]] = {}
+
+    def register(self, name: str, command: Callable[..., None]) -> None:
+        self._commands[name] = command
+
+    def get(self, name: str) -> Callable[..., None]:
+        return self._commands[name]
+

fapilot/middleware.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from fapilot.conf import get_settings
+
+
+def install_cors(app: FastAPI) -> None:
+    settings = get_settings()
+    if settings.CORS_ALLOWED_ORIGINS:
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=settings.CORS_ALLOWED_ORIGINS,
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+

fapilot/pagination.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Generic, TypeVar
+
+from fastapi import Depends, Query
+from pydantic import BaseModel
+
+from fapilot.conf import get_settings
+
+T = TypeVar("T")
+
+
+class Page(BaseModel, Generic[T]):
+    items: Sequence[T]
+    total: int
+    limit: int
+    offset: int
+
+
+class LimitOffset(BaseModel):
+    limit: int
+    offset: int
+
+
+def pagination_params(
+    limit: int | None = Query(default=None, ge=1),
+    offset: int = Query(default=0, ge=0),
+) -> LimitOffset:
+    settings = get_settings()
+    chosen_limit = limit or settings.DEFAULT_PAGE_SIZE
+    return LimitOffset(limit=min(chosen_limit, settings.MAX_PAGE_SIZE), offset=offset)
+
+
+Pagination = Depends(pagination_params)

fapilot/permissions/__init__.py

@@ -0,0 +1,4 @@
+from fapilot.permissions.base import AllowAny, IsAuthenticated, Permission
+
+__all__ = ["AllowAny", "IsAuthenticated", "Permission"]
+

fapilot/permissions/base.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from fastapi import HTTPException, Request, status
+
+
+class Permission(Protocol):
+    async def has_permission(self, request: Request) -> bool: ...
+
+
+class AllowAny:
+    async def has_permission(self, request: Request) -> bool:
+        return True
+
+
+class IsAuthenticated:
+    async def has_permission(self, request: Request) -> bool:
+        return getattr(request.state, "user", None) is not None
+
+
+async def require_permissions(request: Request, *permissions: Permission) -> None:
+    for permission in permissions:
+        if not await permission.has_permission(request):
+            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Permission denied")
+

fapilot/py.typed

@@ -0,0 +1 @@
+

fapilot/realtime/__init__.py

@@ -0,0 +1,5 @@
+from fapilot.realtime.sse import EventSourceResponse, sse_event
+from fapilot.realtime.websockets import WebSocketHub
+
+__all__ = ["EventSourceResponse", "WebSocketHub", "sse_event"]
+

fapilot/realtime/sse.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterable
+from typing import Any
+
+from starlette.responses import StreamingResponse
+
+
+def sse_event(data: Any, *, event: str | None = None, event_id: str | None = None) -> str:
+    lines: list[str] = []
+    if event_id:
+        lines.append(f"id: {event_id}")
+    if event:
+        lines.append(f"event: {event}")
+    payload = data if isinstance(data, str) else json.dumps(data)
+    for line in payload.splitlines():
+        lines.append(f"data: {line}")
+    return "\n".join(lines) + "\n\n"
+
+
+class EventSourceResponse(StreamingResponse):
+    def __init__(self, content: AsyncIterable[str]) -> None:
+        super().__init__(content, media_type="text/event-stream")
+

fapilot/realtime/websockets.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from fastapi import WebSocket
+
+
+class WebSocketHub:
+    def __init__(self) -> None:
+        self.connections: set[WebSocket] = set()
+
+    async def connect(self, websocket: WebSocket) -> None:
+        await websocket.accept()
+        self.connections.add(websocket)
+
+    def disconnect(self, websocket: WebSocket) -> None:
+        self.connections.discard(websocket)
+
+    async def broadcast_text(self, message: str) -> None:
+        stale: list[WebSocket] = []
+        for websocket in self.connections:
+            try:
+                await websocket.send_text(message)
+            except RuntimeError:
+                stale.append(websocket)
+        for websocket in stale:
+            self.disconnect(websocket)
+

fapilot/responses.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi.responses import JSONResponse
+
+
+def ok(data: Any = None, *, status_code: int = 200) -> JSONResponse:
+    return JSONResponse({"data": data}, status_code=status_code)
+

fapilot/testing/__init__.py

@@ -0,0 +1,4 @@
+from fapilot.testing.client import AsyncTestClient
+
+__all__ = ["AsyncTestClient"]
+

fapilot/testing/client.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from httpx import ASGITransport, AsyncClient
+
+
+@asynccontextmanager
+async def AsyncTestClient(app: FastAPI) -> AsyncIterator[AsyncClient]:
+    async with AsyncClient(
+        transport=ASGITransport(app=app),
+        base_url="http://testserver",
+    ) as client:
+        yield client
+

fapilot-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fapilot maintainers
+
+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.

fapilot-0.1.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.2
+Name: fapilot
+Version: 0.1.0
+Summary: A Django-inspired async application framework built on FastAPI, Tortoise ORM, and Aerich.
+Author: Ali Hajiali
+Maintainer: Ali Hajiali
+License: MIT
+Project-URL: Homepage, https://github.com/alihajiali/fapilot
+Project-URL: Repository, https://github.com/alihajiali/fapilot
+Project-URL: Issues, https://github.com/alihajiali/fapilot/issues
+Project-URL: Changelog, https://github.com/alihajiali/fapilot/blob/main/CHANGELOG.md
+Keywords: fastapi,async,framework,tortoise-orm,aerich,django-inspired
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+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 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi<0.142,>=0.141
+Requires-Dist: starlette<0.50,>=0.49
+Requires-Dist: pydantic<3,>=2.12
+Requires-Dist: pydantic-settings<3,>=2.10
+Requires-Dist: tortoise-orm[asyncpg]<1.2,>=1.1
+Requires-Dist: aerich[toml]<0.11,>=0.10
+Requires-Dist: uvicorn[standard]<0.36,>=0.35
+Requires-Dist: python-jose<4,>=3.5
+Requires-Dist: passlib[bcrypt]<2,>=1.7
+Requires-Dist: python-multipart<0.0.21,>=0.0.20
+Provides-Extra: dev
+Requires-Dist: build<2,>=1.3; extra == "dev"
+Requires-Dist: pytest<9,>=8.4; extra == "dev"
+Requires-Dist: pytest-anyio>=0.0.0; extra == "dev"
+Requires-Dist: httpx<0.29,>=0.28; extra == "dev"
+Requires-Dist: ruff<0.13,>=0.12; extra == "dev"
+Requires-Dist: pyright<2,>=1.1; extra == "dev"
+Requires-Dist: twine<7,>=6.2; extra == "dev"
+
+# Fapilot
+
+Fapilot is an opinionated, async-first backend framework built on FastAPI. It borrows Django's project organization, app registry, settings discipline, scaffolding, and management-command ergonomics while keeping FastAPI's dependency injection, OpenAPI, lifespan, and async runtime model.
+
+## Features
+
+- Django-inspired project and app scaffolding.
+- FastAPI application factory with app registry integration.
+- Pydantic settings loader with uppercase application settings.
+- Tortoise ORM configuration and Aerich migration backend.
+- Pagination, filtering, CRUD, permissions, middleware, events, auth, and realtime helpers.
+- CLI commands for project creation, app creation, migrations, and local serving.
+
+## Installation
+
+For local development from this repository:
+
+```bash
+python3.12 -m venv .venv
+source .venv/bin/activate
+python -m pip install -U pip
+python -m pip install -e ".[dev]"
+```
+
+After installation, the `fapilot` command is available on your shell path:
+
+```bash
+fapilot --help
+```
+
+You can also run the CLI directly from a checkout:
+
+```bash
+python3.12 -m fapilot.cli --help
+```
+
+## Quick Start
+
+```bash
+python3.12 -m pip install -e .
+fapilot startproject myproject
+cd myproject
+fapilot startapp users
+fapilot makemigrations
+fapilot migrate
+fapilot runserver
+```
+
+Core stack:
+
+- FastAPI + Starlette lifespan
+- Pydantic v2 + pydantic-settings
+- Tortoise ORM
+- Aerich migrations through a backend abstraction
+- Uvicorn
+- pytest, HTTPX, AnyIO
+- Ruff and Pyright
+
+This repository contains the reusable framework package. Generated projects contain `config/`, `apps/`, `common/`, `manage.py`, Docker files, `.env`, and a project-local `pyproject.toml`.
+
+## CLI
+
+```bash
+fapilot startproject myproject
+fapilot startapp users
+fapilot makemigrations --name initial
+fapilot migrate
+fapilot runserver --host 127.0.0.1 --port 8000
+```
+
+## Development
+
+```bash
+ruff check .
+pyright
+pytest
+python -m build
+twine check dist/*
+```
+
+## Release
+
+See [RELEASE.md](RELEASE.md) for the release checklist and PyPI publishing flow.
+
+## License
+
+Fapilot is released under the MIT License. See [LICENSE](LICENSE).

fapilot-0.1.0.dist-info/RECORD

@@ -0,0 +1,40 @@
+fapilot/__init__.py,sha256=J6rLlmU-8CEoeiHp-rKZ5I25Gv9JlqT-2piWIkrgpmA,132
+fapilot/cli.py,sha256=MbTHduI2zOh8nR_psTb36_aDKx10hFk54Js495MvIJQ,6439
+fapilot/crud.py,sha256=F_lcVzEZqpm7MfpgYBbNGSKWiF6Zp4UikeX4gZyjRFo,1427
+fapilot/exceptions.py,sha256=qGDMYEt_1TcKTfiJP7RnHMy5TVY4gbyCzSUB4bR1_Ew,129
+fapilot/filtering.py,sha256=LZqbpRDj6L36v6YVo2PtPT5pa5isa7PKVtFBxdRmU-A,238
+fapilot/middleware.py,sha256=JlyEjCBI64805zYf5unll1kp0tuHBwlDH3hucrgCz8s,490
+fapilot/pagination.py,sha256=dtpqjsn4RKROK-ZarPwWDhn-D0uI8tFhps2xawPMta8,752
+fapilot/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+fapilot/responses.py,sha256=hXdS6MbonAqrpJGfk_BR606g-4HqTkW9Phh9rv2WCZ8,240
+fapilot/apps/__init__.py,sha256=_S4pBcO7UkREcPm2Gf6GP7rf25GX2Ua4Sh-ENO60y6I,129
+fapilot/apps/config.py,sha256=ztb5yJcgSLBrlNWJZhvukc7LP93KXTrjUB0V-ionWvg,891
+fapilot/apps/registry.py,sha256=1fmG8cu7Z13sk76k5hW46sgfhRjG7jlYxsTCH0LSVnM,1454
+fapilot/auth/__init__.py,sha256=N-hLFiXPvRam2vxVsHXJbrHawnrYv2L8VSN9Fyi_O9s,231
+fapilot/auth/jwt.py,sha256=K_ef4PUbNTlXLaXl1oFqgP0baackzFJz42jEpJ_EcpI,896
+fapilot/auth/passwords.py,sha256=Ng5x3xJY_HBU0x1iPEUC6d0SLAtpK6iGUxFlQatf4a8,351
+fapilot/background/__init__.py,sha256=awrJ0Uhf3DgOlqf_c0sGdJUTIn7FyeLEJRbggRetUYU,73
+fapilot/background/tasks.py,sha256=Qqctpmkr-HuKiTBTOYoQfeXwcHt4B_uyZbOgHWwhlRI,349
+fapilot/conf/__init__.py,sha256=OiHubavsDToAvPsS2ENYCGULjj2t1R5yiqkyVNpK7NI,144
+fapilot/conf/settings.py,sha256=FJmgdb_u4cOeKL1ImpfkNZOFTHKTTZWN26J9VF66H70,2023
+fapilot/core/application.py,sha256=tN-fH06ejjiMmbsQ_DxHaAlAow30g4n6CdyUAGDAMvU,2660
+fapilot/db/__init__.py,sha256=uuM0ctHBQEHdDv916FbjyinB00KoOGlzp4G2kglg3Wk,134
+fapilot/db/migrations.py,sha256=IKiaerTaACGQkYx7dxrpxgY63AvzSvNTsiVtt5wWUWo,1039
+fapilot/db/tortoise.py,sha256=WZan7hTZCf8YNR7pGiHlwpdrqzSsRVrcawD50r7Ldsc,956
+fapilot/events/__init__.py,sha256=_0HZCJcleKYxMaSJZ_gZ-T9RxsMw85-nhb75tN3vxR4,88
+fapilot/events/dispatcher.py,sha256=_1nZpudAUpc-OlWsLAxJ78GSrvWjX_zN7kg53yZGjWg,687
+fapilot/management/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+fapilot/management/commands.py,sha256=W72PqEMwPgGik3qJp3eIS0DvCnvjhC8clFQnVoYTkGM,394
+fapilot/permissions/__init__.py,sha256=xL820vD0TBpKhlN5V6oF06OkXjVZvKA5Afw166d5zQI,133
+fapilot/permissions/base.py,sha256=4EwcXN8MVxpw39q8DMpeED6z2-2FlJyAiqhjY38ld4o,740
+fapilot/realtime/__init__.py,sha256=DDw_AyPOg1rtS0nqZPNbXW4755hMWoyjJoXzzAffryU,182
+fapilot/realtime/sse.py,sha256=RfrahRxsYevY3iLwgY03rlf8kquazERaiATsXiToMN0,749
+fapilot/realtime/websockets.py,sha256=RjGwp7uAoDgFsVezGV-gCw2jcS5HcstADa5LrmVP7fE,754
+fapilot/testing/__init__.py,sha256=ITVn2wFLGLrAFRLHkyfz7-Wvvzx41nXEgHbj_enSc4Y,83
+fapilot/testing/client.py,sha256=8-EegMiU76rN_LYCxtweNoB6L4MyuEKQOkDRoEJRUsw,436
+fapilot-0.1.0.dist-info/LICENSE,sha256=htg2Bz7VZtqVFWWuLBWnUbYEGqvYbv77drVoMIvfjBg,1076
+fapilot-0.1.0.dist-info/METADATA,sha256=-WQw5ZBJ7XeUy_IzOGp8HWxj2Sjq2gaZYwhMnvZ4TYU,4133
+fapilot-0.1.0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+fapilot-0.1.0.dist-info/entry_points.txt,sha256=3K-ijMOGboG4CBmMD2HKvYly7qtxl_jkc7Ax4mCNkwc,45
+fapilot-0.1.0.dist-info/top_level.txt,sha256=Mu-7cNCqmfAlxqaeV6daEf2V4neAxQS1BQZAOMX3SLc,8
+fapilot-0.1.0.dist-info/RECORD,,

fapilot-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (76.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fapilot-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fapilot = fapilot.cli:main

fapilot-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fapilot