Starlite is a powerful, performant, flexible and opinionated ASGI framework, offering first class typing support and a full Pydantic integration.
Check out the documentation π.
pip install starlitefrom starlite import Starlite, get
@get("/")
def hello_world() -> dict[str, str]:
"""Keeping the tradition alive with hello world."""
return {"hello": "world"}
app = Starlite(route_handlers=[hello_world])- Class based controllers
- Dependency Injection
- Validation and Parsing using Pydantic
- Layered Middleware
- Plugin System
- OpenAPI 3.1 schema generation
- Life Cycle Hooks
- Route Guards based Authorization
- Layered Parameter declaration
- SQLAlchemy Support (via plugin)
- Piccolo ORM Support (via plugin)
- Tortoise ORM Support (via plugin)
- Extended testing support
- Automatic API documentation with:
- Support for dataclasses and
TypedDict - Trio support (built-in, via AnyIO)
- Ultra-fast json serialization and deserialization using msgspec
- starlite-pg-redis-docker: In addition to Starlite, this demonstrates a pattern of application modularity, SQLAlchemy 2.0 ORM, Redis cache connectivity, and more. Like all Starlite projects, this application is open to contributions, big and small.
- starlite-hello-world: A bare-minimum application setup. Great for testing and POC work.
Starlite was originally built using the Starlette ASGI toolkit. The name Starlite was
meant to show this relation. But, over time Starlite grew in capabilities and complexity, and eventually we no longer needed
to depend on Starlette. From version 1.39.0 onward starlette was removed as a dependency of Starlite, and the name now carries
this piece of history with it.
Starlite is fast. It is on par with, or significantly faster than comparable ASGI frameworks.
You can see and run the benchmarks here, or read more about it here in our documentation.
While supporting function based route handlers, Starlite also supports and promotes python OOP using class based controllers:
from typing import List, Optional
from pydantic import UUID4
from starlite import Controller, Partial, get, post, put, patch, delete
from datetime import datetime
from my_app.models import User
class UserController(Controller):
path = "/users"
@post()
async def create_user(self, data: User) -> User:
...
@get()
async def list_users(self) -> List[User]:
...
@get(path="/{date:int}")
async def list_new_users(self, date: datetime) -> List[User]:
...
@patch(path="/{user_id:uuid}")
async def partial_update_user(self, user_id: UUID4, data: Partial[User]) -> User:
...
@put(path="/{user_id:uuid}")
async def update_user(self, user_id: UUID4, data: User) -> User:
...
@get(path="/{user_name:str}")
async def get_user_by_name(self, user_name: str) -> Optional[User]:
...
@get(path="/{user_id:uuid}")
async def get_user(self, user_id: UUID4) -> User:
...
@delete(path="/{user_id:uuid}")
async def delete_user(self, user_id: UUID4) -> None:
...One key difference between Starlite and Starlette/FastAPI is in parsing of form data and query parameters- Starlite supports mixed form data and has faster and better query parameter parsing.
Starlite is rigorously typed, and it enforces typing. For example, if you forget to type a return value for a route handler, an exception will be raised. The reason for this is that Starlite uses typing data to generate OpenAPI specs, as well as to validate and parse data. Thus typing is absolutely essential to the framework.
Furthermore, Starlite allows extending its support using plugins.
Starlite has a plugin system that allows the user to extend serialization/deserialization, OpenAPI generation and other features. It ships with a builtin plugin for SQL Alchemy, which allows the user to use SQLAlchemy declarative classes "natively", i.e. as type parameters that will be serialized/deserialized and to return them as values from route handlers.
Starlite also supports the programmatic creation of DTOs with a DTOFactory class, which also supports the use of
plugins.
Starlite has custom logic to generate OpenAPI 3.1.0 schema, the latest version. The schema generated by Starlite is
significantly more complete and more correct than those generated by FastAPI, and they include optional generation of
examples using the pydantic-factories library.
Starlite serves the documentation from the generated OpenAPI schema with:
All these are available and enabled by default.
Starlite has a simple but powerful DI system inspired by pytest. You can define named dependencies - sync or async - at different levels of the application, and then selective use or overwrite them.
from starlite import Starlite, Provide, get
async def my_dependency() -> str:
...
@get("/")
async def index(injected: str) -> str:
return injected
app = Starlite([index], dependencies={"injected": Provide(my_dependency)})Starlite supports typical ASGI middleware and ships with middlewares to handle things such as
- CORS
- CSRF
- Rate limiting
- GZip and Brotli compression
- Client- and server-side sessions
Starlite has an authorization mechanism called guards, which allows the user to define guard functions at different
level of the application (app, router, controller etc.) and validate the request before hitting the route handler
function.
from starlite import (
Starlite,
get,
ASGIConnection,
NotAuthorizedException,
BaseRouteHandler,
)
async def is_authorized(connection: ASGIConnection, handler: BaseRouteHandler) -> None:
# validate authorization
# if not authorized, raise NotAuthorizedException
raise NotAuthorizedException()
@get("/", guards=[is_authorized])
async def index() -> None:
...
app = Starlite([index])Starlite supports request life cycle hooks, similarly to Flask - i.e. before_request and after_request
Starlite is open to contributions big and small. You can always join our discord server or join our Matrix space to discuss contributions and project maintenance. For guidelines on how to contribute, please see the contribution guide.
Thanks goes to these wonderful people (emoji key):
This project follows the all-contributors specification. Contributions of any kind welcome!