drfast-api 0.1.0__tar.gz

drfast_api-0.1.0/.env.example

@@ -0,0 +1,3 @@
+DEBUG=true
+DATABASE_URL=sqlite://db.sqlite3
+SECRET_KEY=change-me-in-production

drfast_api-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  quality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.11"
+      - run: uv sync
+      - run: uv run ruff check .
+      - run: uv run mypy src
+      - run: uv run pytest
+      - run: uv run bandit -q -r src
+      - run: uv run pip-audit --skip-editable
+      - run: uv build
+

drfast_api-0.1.0/.github/workflows/deploy_pypi.yml

@@ -0,0 +1,20 @@
+name: Publish
+
+on:
+  push:
+    tags: ["v*"]
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  pypi:
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv build
+      - uses: pypa/gh-action-pypi-publish@release/v1
+

drfast_api-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.venv/
+dist/
+build/
+*.egg-info/
+*.db
+.env

drfast_api-0.1.0/.readthedocs.yaml

@@ -0,0 +1,17 @@
+version: 2
+
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.12"
+
+sphinx:
+  configuration: docs/conf.py
+  fail_on_warning: true
+
+python:
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - docs

drfast_api-0.1.0/LICENSE

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

drfast_api-0.1.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.5
+Name: drfast-api
+Version: 0.1.0
+Summary: DRF-inspired async APIs for FastAPI and Tortoise ORM
+Project-URL: Documentation, https://github.com/drfast-api/drfast-api#readme
+Project-URL: Issues, https://github.com/drfast-api/drfast-api/issues
+Project-URL: Source, https://github.com/drfast-api/drfast-api
+Author: DRFast API contributors
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: FastAPI
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: email-validator<3,>=2.2
+Requires-Dist: fastapi-users<16,>=15.0.5
+Requires-Dist: fastapi<1,>=0.115
+Requires-Dist: pydantic-settings<3,>=2.3
+Requires-Dist: pydantic<3,>=2.7
+Requires-Dist: tortoise-orm<2,>=1
+Requires-Dist: uvicorn[standard]<1,>=0.30
+Provides-Extra: docs
+Requires-Dist: sphinx<9,>=8; extra == 'docs'
+Provides-Extra: postgres
+Requires-Dist: asyncpg<1,>=0.29; extra == 'postgres'
+Description-Content-Type: text/markdown
+
+# DRFast API
+
+DRFast API brings familiar Django REST Framework patterns to fully async FastAPI applications backed by Tortoise ORM.
+
+It is pre-1.0 software. The public surface includes serializers, model viewsets, routers, permissions, middleware, settings, Tortoise lifecycle integration, FastAPI Users integration, and the `drfast` management CLI.
+
+## Quick start
+
+```bash
+uv add drfast-api
+drfast startproject config
+cd config
+drfast migrate
+drfast runserver
+```
+
+Generated projects use SQLite locally. Set `DATABASE_URL` to a PostgreSQL URL and install `drfast-api[postgres]` for production.
+
+## Application structure
+
+Projects explicitly list Tortoise model modules in `Settings.installed_apps`. A generated app keeps models, serializers, and views separate:
+
+```python
+class TodoSerializer(ModelSerializer[Todo]):
+	model = Todo
+	id = UUIDField(read_only=True)
+	title = CharField()
+
+
+class TodoViewSet(ModelViewSet):
+	model = Todo
+	serializer_class = TodoSerializer
+	ordering_fields = ("created_at", "title")
+```
+
+Register it with `DefaultRouter`, then include the router in the FastAPI application. Viewset handlers, serializer hooks, permission methods, and middleware hooks are asynchronous.
+
+`drfast` delegates migration operations to Tortoise’s current built-in migration CLI:
+
+```bash
+drfast init
+drfast makemigrations --name add_todos
+drfast migrate
+drfast history
+```
+
+The starter’s authentication uses FastAPI Users with DRFast’s Tortoise adapter. It enables registration and bearer JWT login; password reset and email verification require application-provided delivery hooks before they are enabled.
+
+## Configuration
+
+Copy `.env.example` to `.env` in generated projects. `SECRET_KEY` must be changed and `DEBUG=false` set for production. SQLite is suitable for local development and isolated tests; production should use PostgreSQL, explicit migrations, and an `asyncpg` connection URL.
+
+## Development
+
+```bash
+uv sync
+uv run ruff check .
+uv run mypy src
+uv run pytest
+uv run bandit -q -r src
+uv run pip-audit --skip-editable
+uv run python -m build
+```
+
+The CI workflow also runs Bandit and pip-audit. Configure the PyPI trusted publisher for the `pypi` GitHub environment before tagging a release.
+

drfast_api-0.1.0/README.md

@@ -0,0 +1,66 @@
+# DRFast API
+
+DRFast API brings familiar Django REST Framework patterns to fully async FastAPI applications backed by Tortoise ORM.
+
+It is pre-1.0 software. The public surface includes serializers, model viewsets, routers, permissions, middleware, settings, Tortoise lifecycle integration, FastAPI Users integration, and the `drfast` management CLI.
+
+## Quick start
+
+```bash
+uv add drfast-api
+drfast startproject config
+cd config
+drfast migrate
+drfast runserver
+```
+
+Generated projects use SQLite locally. Set `DATABASE_URL` to a PostgreSQL URL and install `drfast-api[postgres]` for production.
+
+## Application structure
+
+Projects explicitly list Tortoise model modules in `Settings.installed_apps`. A generated app keeps models, serializers, and views separate:
+
+```python
+class TodoSerializer(ModelSerializer[Todo]):
+	model = Todo
+	id = UUIDField(read_only=True)
+	title = CharField()
+
+
+class TodoViewSet(ModelViewSet):
+	model = Todo
+	serializer_class = TodoSerializer
+	ordering_fields = ("created_at", "title")
+```
+
+Register it with `DefaultRouter`, then include the router in the FastAPI application. Viewset handlers, serializer hooks, permission methods, and middleware hooks are asynchronous.
+
+`drfast` delegates migration operations to Tortoise’s current built-in migration CLI:
+
+```bash
+drfast init
+drfast makemigrations --name add_todos
+drfast migrate
+drfast history
+```
+
+The starter’s authentication uses FastAPI Users with DRFast’s Tortoise adapter. It enables registration and bearer JWT login; password reset and email verification require application-provided delivery hooks before they are enabled.
+
+## Configuration
+
+Copy `.env.example` to `.env` in generated projects. `SECRET_KEY` must be changed and `DEBUG=false` set for production. SQLite is suitable for local development and isolated tests; production should use PostgreSQL, explicit migrations, and an `asyncpg` connection URL.
+
+## Development
+
+```bash
+uv sync
+uv run ruff check .
+uv run mypy src
+uv run pytest
+uv run bandit -q -r src
+uv run pip-audit --skip-editable
+uv run python -m build
+```
+
+The CI workflow also runs Bandit and pip-audit. Configure the PyPI trusted publisher for the `pypi` GitHub environment before tagging a release.
+

drfast_api-0.1.0/docs/api.rst

@@ -0,0 +1,6 @@
+API reference
+=============
+
+.. automodule:: drfast
+   :members:
+   :undoc-members:

drfast_api-0.1.0/docs/conf.py

@@ -0,0 +1,12 @@
+"""Sphinx configuration for DRFast API."""
+
+project = "DRFast API"
+copyright = "2026, DRFast API contributors"
+author = "DRFast API contributors"
+
+extensions = ["sphinx.ext.autodoc", "sphinx.ext.napoleon"]
+templates_path = ["_templates"]
+exclude_patterns: list[str] = []
+
+html_theme = "alabaster"
+autodoc_typehints = "description"

drfast_api-0.1.0/docs/index.rst

@@ -0,0 +1,11 @@
+DRFast API
+==========
+
+DRFast API provides Django REST Framework-inspired async primitives for
+FastAPI applications using Tortoise ORM.
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Reference
+
+   api

drfast_api-0.1.0/pyproject.toml

@@ -0,0 +1,75 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "drfast-api"
+version = "0.1.0"
+description = "DRF-inspired async APIs for FastAPI and Tortoise ORM"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "DRFast API contributors" }]
+classifiers = [
+	"Development Status :: 2 - Pre-Alpha",
+	"Framework :: FastAPI",
+	"Framework :: AsyncIO",
+	"License :: OSI Approved :: MIT License",
+	"Programming Language :: Python :: 3 :: Only",
+	"Programming Language :: Python :: 3.11",
+	"Programming Language :: Python :: 3.12",
+	"Programming Language :: Python :: 3.13",
+]
+dependencies = [
+	"fastapi>=0.115,<1",
+	"fastapi-users>=15.0.5,<16",
+	"email-validator>=2.2,<3",
+	"pydantic>=2.7,<3",
+	"pydantic-settings>=2.3,<3",
+	"tortoise-orm>=1,<2",
+	"uvicorn[standard]>=0.30,<1",
+]
+
+[project.optional-dependencies]
+postgres = ["asyncpg>=0.29,<1"]
+docs = ["sphinx>=8,<9"]
+
+[dependency-groups]
+dev = [
+	"httpx>=0.27,<1",
+	"pytest>=9.0.3,<10",
+	"pytest-asyncio>=0.23,<1",
+	"ruff>=0.8,<1",
+	"mypy>=1.13,<2",
+	"bandit>=1.7,<2",
+	"pip-audit>=2.7,<3",
+]
+
+[project.scripts]
+drfast = "drfast.cli:main"
+
+[project.urls]
+Documentation = "https://github.com/drfast-api/drfast-api#readme"
+Issues = "https://github.com/drfast-api/drfast-api/issues"
+Source = "https://github.com/drfast-api/drfast-api"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/drfast"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+src = ["src"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+files = ["src"]
+

drfast_api-0.1.0/src/drfast/__init__.py

@@ -0,0 +1,44 @@
+"""DRF-inspired primitives for async FastAPI applications."""
+
+from drfast.filters import FilterSet
+from drfast.middleware import BaseMiddleware
+from drfast.models import Model, SoftDeleteModel, TimestampedModel
+from drfast.pagination import LimitOffsetPagination
+from drfast.permissions import AllowAny, BasePermission, IsAdminUser, IsAuthenticated
+from drfast.routers import DefaultRouter
+from drfast.serializers import (
+	BooleanField,
+	CharField,
+	EmailField,
+	IntegerField,
+	ModelSerializer,
+	Serializer,
+	UUIDField,
+)
+from drfast.settings import DRFastSettings
+from drfast.views import APIView, ModelViewSet
+
+__all__ = [
+	"APIView",
+	"AllowAny",
+	"BaseMiddleware",
+	"BasePermission",
+	"BooleanField",
+	"CharField",
+	"DRFastSettings",
+	"DefaultRouter",
+	"EmailField",
+	"FilterSet",
+	"IntegerField",
+	"IsAdminUser",
+	"IsAuthenticated",
+	"LimitOffsetPagination",
+	"Model",
+	"ModelSerializer",
+	"ModelViewSet",
+	"Serializer",
+	"SoftDeleteModel",
+	"TimestampedModel",
+	"UUIDField",
+]
+

drfast_api-0.1.0/src/drfast/auth.py

@@ -0,0 +1,126 @@
+"""Current FastAPI Users integration backed by Tortoise ORM.
+
+FastAPI Users no longer ships a Tortoise adapter. This module maintains the
+small persistence bridge while leaving its authentication and security flows
+to FastAPI Users.
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator, Callable
+from typing import Any, Generic, Protocol, Self, TypeVar
+from uuid import UUID
+
+from fastapi import Depends, Request
+from fastapi_users import BaseUserManager, FastAPIUsers
+from fastapi_users.authentication import AuthenticationBackend, BearerTransport, JWTStrategy
+from fastapi_users.db import BaseUserDatabase
+from fastapi_users.manager import UUIDIDMixin
+from fastapi_users.models import UserProtocol
+from tortoise import fields
+
+from drfast.models import Model, TimestampedModel
+
+
+class TortoiseUserProtocol(UserProtocol[UUID], Protocol):
+	"""Structural contract required by the Tortoise FastAPI Users adapter."""
+
+	@classmethod
+	async def get_or_none(cls, **kwargs: Any) -> Self | None: ...
+
+	@classmethod
+	async def create(cls, **kwargs: Any) -> Self: ...
+
+	async def save(self, *, update_fields: list[str]) -> None: ...
+
+	async def delete(self) -> None: ...
+
+
+UserType = TypeVar("UserType", bound=TortoiseUserProtocol)
+AuthUserType = TypeVar("AuthUserType", bound=UserProtocol[UUID])
+
+
+class FastAPIUserModel(Model, TimestampedModel):
+	"""Ready-to-use Tortoise user table base with FastAPI Users fields."""
+
+	email = fields.CharField(max_length=320, unique=True, index=True)
+	hashed_password = fields.CharField(max_length=1024)
+	is_active = fields.BooleanField(default=True)
+	is_superuser = fields.BooleanField(default=False)
+	is_verified = fields.BooleanField(default=False)
+
+	class Meta:
+		abstract = True
+
+
+class TortoiseUserDatabase(BaseUserDatabase[UserType, UUID], Generic[UserType]):
+	"""FastAPI Users persistence adapter for a Tortoise UUID user model."""
+
+	def __init__(self, user_model: type[UserType]) -> None:
+		self.user_model = user_model
+
+	async def get(self, id: UUID) -> UserType | None:
+		return await self.user_model.get_or_none(id=id)
+
+	async def get_by_email(self, email: str) -> UserType | None:
+		return await self.user_model.get_or_none(email=email)
+
+	async def create(self, create_dict: dict[str, Any]) -> UserType:
+		return await self.user_model.create(**create_dict)
+
+	async def update(self, user: UserType, update_dict: dict[str, Any]) -> UserType:
+		for key, value in update_dict.items():
+			setattr(user, key, value)
+		await user.save(update_fields=list(update_dict))
+		return user
+
+	async def delete(self, user: UserType) -> None:
+		await user.delete()
+
+
+class DRFastUserManager(UUIDIDMixin, BaseUserManager[UserType, UUID], Generic[UserType]):
+	"""Base manager applications subclass to add password and event policies."""
+
+	reset_password_token_secret: str
+	verification_token_secret: str
+
+
+def jwt_authentication(
+	secret: str,
+	lifetime_seconds: int = 3600,
+) -> AuthenticationBackend[AuthUserType, UUID]:
+	"""Build FastAPI Users' bearer/JWT backend for generated projects."""
+	bearer_transport = BearerTransport(tokenUrl="auth/jwt/login")
+
+	def get_strategy() -> JWTStrategy[AuthUserType, UUID]:
+		return JWTStrategy(secret=secret, lifetime_seconds=lifetime_seconds)
+
+	return AuthenticationBackend[AuthUserType, UUID](
+		name="jwt", transport=bearer_transport, get_strategy=get_strategy
+	)
+
+
+def build_fastapi_users(
+	get_user_manager: Callable[..., AsyncGenerator[DRFastUserManager[UserType], None]],
+	backend: AuthenticationBackend[UserType, UUID],
+) -> FastAPIUsers[UserType, UUID]:
+	"""Create a FastAPI Users facade from application dependencies."""
+	return FastAPIUsers(get_user_manager, [backend])
+
+
+def current_user_middleware(
+	current_active_user: Callable[..., Any],
+) -> Callable[[Request, Any], Any]:
+	"""Adapt a FastAPI Users dependency for DRFast permission classes.
+
+	Use this with a normal FastAPI dependency on protected routes when request
+	state is desired by custom `BasePermission` implementations.
+	"""
+	async def dependency(  # noqa: B008 - FastAPI resolves dependencies from the signature.
+		request: Request, user: Any = Depends(current_active_user)  # noqa: B008
+	) -> Any:
+		request.state.user = user
+		return user
+
+	return dependency
+