starlite 1.35.0

Light-weight and flexible ASGI API Framework

Starlite

Starlite is a powerful, flexible and highly performant ASGI API framework built on top of Starlette and pydantic.

Check out the Starlite documentation 📚

Installation

pip install starlite

Quick Start

from 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])

Core Features

• Both functional and OOP python support
• Class based controllers
• Extended testing support
• Builtin Validation and Parsing using Pydantic
• Dataclass Support
• Dependency Injection
• Layered Middleware
• Layered Parameter declaration
• Route Guards based Authorization
• Life Cycle Hooks
• Plugin System
• SQLAlchemy Support (via plugin)
• Tortoise-ORM Support (via plugin)
• Trio support (built-in, via AnyIO)
• Automatic OpenAPI 3.1 schema generation
• Support for Redoc
• Support for Swagger-UI
• Support for Stoplight Elements
• Ultra-fast json serialization and deserialization using orjson

Example Applications

• 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.

Relation to Starlette and FastAPI

Although Starlite uses the Starlette ASGI toolkit, it does not simply extend Starlette, as FastAPI does. Starlite uses selective pieces of Starlette while implementing its own routing and parsing logic, the primary reason for this is to enforce a set of best practices and discourage misuse. This is done to promote simplicity and scalability - Starlite is simple to use, easy to learn, and unlike both Starlette and FastAPI - it keeps complexity low when scaling.

Performant

Additionally, Starlite is very fast in comparison to other ASGI frameworks. In fact, the only framework that is faster in our benchmarks is BlackSheep, which is almost completely written in cython and does not work with pydantic out of the box as such:

JSON Benchmarks

PlainText Benchmarks

Legend:

• a-: async, s-: sync
• np: no params, pp: path param, qp: query param, mp: mixed params

You can see and run the benchmarks here.

Class Based Controllers

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:
        ...

ReDoc, Swagger-UI and Stoplight Elements API Documentation

While running Starlite, you can view the generated OpenAPI documentation using a ReDoc site, a Swagger-UI as well as a Stoplight Elements site.

Data Parsing, Type Hints and Pydantic

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.

SQLAlchemy Support, Plugin System and DTOs

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.

OpenAPI

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.

Dependency Injection

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.

Middleware

Starlite supports the Starlette Middleware system while simplifying it and offering builtin configuration of CORS and some other middlewares.

Route Guards

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.

Request Life Cycle Hooks

Starlite supports request life cycle hooks, similarly to Flask - i.e. before_request and after_request

Contributing

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.

Contributors ✨

Thanks goes to these wonderful people (emoji key):

Na'aman Hirschfeld 🚧 💻 📖	Peter Schutt 🚧 💻 📖	Ashwin Vinod 💻 📖	Damian 📖	Vincent Sarago 💻	Jonas Krüger Svensson 📦	Sondre Lillebø Gundersen 📦
Lev 💻 🤔	Tim Wedde 💻	Tory Clasen 💻	Arseny Boykov 💻 🤔	Jacob Rodgers 💡	Dane Solberg 💻	madlad33 💻
Matthew Aylward 💻	Jan Klima 💻	C2D ⚠️	to-ph 💻	imbev 📖	cătălin 💻	Seon82 📖
Slava 💻	Harry 💻 📖	Cody Fincher 💻 📖 🚧	Christian Clauss 📖	josepdaniel 💻	devtud 🐛	Nicholas Ramos 💻
seladb 📖 💻	Simon Wienhöfer 💻	MobiusXS 💻	Aidan Simard 📖	wweber 💻	Samuel Colvin 💻	Mateusz Mikołajczyk 💻
Alex 💻	Odiseo 📖	Javier Pinilla 💻	Chaoying 📖	infohash 💻	John Ingles 💻	Eugene ⚠️ 💻
Jon Daly 📖 💻	Harshal Laheri 💻 📖	Téva KRIEF 💻	Konstantin Mikhailov 📖 💻	Mitchell Henry 📖	chbndrhnns 📖	nielsvanhooy 💻
provinzkraut ⚠️ 💻	Joshua Bronson 📖	Roman Reznikov 📖	mookrs 📖	Mike DePalatis 📖	Carlos Alberto Pérez-Molano 📖	ThinksFast ⚠️

This project follows the all-contributors specification. Contributions of any kind welcome!