fast-django-asgi 0.1.3.post1

Django-like developer experience on ASGI powered by FastAPI, Tortoise ORM, Aerich, and FastAPI-Admin.

fast-django

Django-like Developer Experience on ASGI with FastAPI, Tortoise ORM, Aerich, and FastAPI-Admin

Documentation • Examples • API Reference • Contributing

🚀 What is fast-django?

fast-django brings the familiar Django development experience to modern ASGI applications, combining the power of FastAPI with Django's developer-friendly patterns. It provides a clean abstraction layer that makes building high-performance web APIs as intuitive as Django.

✨ Key Features

• 🏗️ Django-style CLI - Familiar manage.py commands for project management
• 🗄️ Tortoise ORM - Django-like ORM with async support and migrations
• 📊 Admin Interface - Auto-mounting admin UI with FastAPI-Admin
• ⚙️ Pydantic Settings - Type-safe configuration with environment variables
• 🛣️ Auto-routing - Automatic router discovery and inclusion
• 🔧 Scaffolding - Generate projects and apps with startproject and startapp
• 🚀 FastAPI-powered - Built on FastAPI for high performance and automatic API docs
• 🔄 Aerich Migrations - Database migrations with automatic discovery
• 🔔 Signals - Django-like request and ORM signals

🚀 Quick Start

Installation

pip install fast-django-asgi

Create Your First Project

# Create a new project
fast-django startproject myblog
cd myblog

# Create an app
fast-django startapp blog

# Set up the database
python manage.py makemigrations
python manage.py migrate

# Create a superuser
python manage.py createsuperuser --email [e-mail]

# Start the development server
python manage.py runserver

Visit http://127.0.0.1:8000 to see your app and http://127.0.0.1:8000/docs for automatic API documentation!

📖 Documentation

• Getting Started - Complete setup guide
• Core Concepts - Routing, ORM, Settings, Middleware, Signals, and more
• Examples - Real-world applications
• API Reference - Complete API documentation

Local Documentation

pip install "fast-django-asgi[docs]"
mkdocs serve

🎯 Why fast-django?

Django Developers

If you love Django's developer experience but need the performance and modern features of FastAPI, fast-django is perfect for you. It provides:

• Familiar CLI commands (manage.py runserver, makemigrations, etc.)
• Django-style project structure and app organization
• Similar ORM patterns and database operations
• Admin interface that works like Django's admin

FastAPI Developers

If you're already using FastAPI but want a more structured approach to building applications, fast-django offers:

• Project scaffolding and app organization
• Database migrations and ORM integration
• Admin interface out of the box
• Settings management with environment variables

Modern Python Web Development

fast-django combines the best of both worlds:

• Performance: Built on FastAPI and ASGI
• Developer Experience: Django-like patterns and CLI
• Type Safety: Full Pydantic integration
• Modern Stack: Async/await, type hints, and modern Python features

🏗️ Architecture

fast-django provides a clean abstraction layer that combines:

• FastAPI for the web framework and API layer
• Tortoise ORM for database operations and models
• Aerich for database migrations
• FastAPI-Admin for the admin interface
• Pydantic for settings and data validation

📦 What's Included

• Core Application Factory: create_app() function for app initialization
• Settings System: Environment-based configuration with FD_ prefix
• ORM Integration: Re-exported Tortoise ORM components
• CLI Tools: Complete command-line interface for project management
• Admin System: Pluggable admin interface with model registration
• Scaffolding: Templates for projects and apps
• Middleware Support: Easy middleware configuration
• Auto-discovery: Automatic app and model discovery

🛠️ Development

Prerequisites

• Python 3.11+
• pip or your preferred package manager

Installation

# Clone the repository
git clone https://github.com/AakarSharma/fast-django.git
cd fast-django

# Install in development mode
pip install -e ".[dev,test,docs]"

# Install pre-commit hooks
pre-commit install

Pre-commit

We use pre-commit to run Ruff and MyPy before each commit.

pip install pre-commit
pre-commit install
# Run on all files
pre-commit run --all-files

Running Tests

# Run all tests
pytest

# Run with coverage
pytest --cov=src/fast_django --cov-report=html

# Run linting
ruff check . && ruff format --check .

# Run type checking
mypy src

Building Documentation

# Serve documentation locally
mkdocs serve

# Build documentation
mkdocs build

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

Quick Contribution Steps

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Make your changes
4. Run tests and linting (pytest && ruff check . && mypy src)
5. Commit your changes (git commit -m 'Add amazing feature')
6. Push to the branch (git push origin feature/amazing-feature)
7. Open a Pull Request

📊 Project Status

• ✅ Core Features: Complete and stable
• ✅ Documentation: Comprehensive and up-to-date
• ✅ Testing: High test coverage with CI/CD
• ✅ Type Safety: Full type hints and mypy compliance
• 🔄 Active Development: Regular updates and improvements

🆘 Support

• 📚 Documentation: https://aakarsharma.github.io/fast-django/
• 🐛 Bug Reports: GitHub Issues
• 💬 Discussions: GitHub Discussions
• 📧 Contact: Create an issue

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• FastAPI - The web framework for building APIs
• Tortoise ORM - The async ORM
• Aerich - Database migrations
• FastAPI-Admin - Admin interface
• Django - Inspiration for developer experience

---

Made with ❤️ by the fast-django community

⭐ Star us on GitHub • 🐛 Report a bug • 💡 Request a feature