nestipy 0.10.1

Nestipy is a Python framework built on top of FastAPI/BlackSheep that follows the modular architecture of NestJS

Description

Nestipy is a Python framework built on top of FastAPI that follows the modular architecture of NestJS

Under the hood, Nestipy makes use of FastAPI, but also provides compatibility with a wide range of other libraries, like Blacksheep, allowing for easy use of the myriad of third-party plugins which are available.

Getting started

    pip install nestipy-cli
    nestipy new my_app
    cd my_app
    nestipy start --dev

    ├── src
    │    ├── __init__.py
    ├── app_module.py
    ├── app_controller.py
    ├── app_service.py
    ├── main.py
    ├── cli.py
    ├── pyproject.yml
    ├── uv.lock
    ├── README.md
    
       

The main.py file contains an instance of the application and bootstraps it with app.listen() (Granian under the hood).

from granian.constants import Interfaces

from nestipy.core import NestipyFactory

from app_module import AppModule

app = NestipyFactory.create(AppModule)

if __name__ == '__main__':
    app.listen(
        "main:app",
        host="0.0.0.0",
        port=8000,
        interface=Interfaces.ASGI,
        reload=True,
    )

Embed mode (no import string, fewer options like reload/workers):

if __name__ == '__main__':
    app.listen(host="0.0.0.0", port=8000)

Inside module, we got,

from app_command import AppCommand
from app_controller import AppController
from app_service import AppService

from nestipy.common import Module


@Module(
    controllers=[AppController],
    providers=[AppService, AppCommand]
)
class AppModule: ...

For controller, we got something like

from typing import Annotated

from nestipy.common import Controller, Get, Post, Put, Delete
from nestipy.ioc import Inject, Body, Param

from app_service import AppService


@Controller()
class AppController:
    service: Annotated[AppService, Inject()]

    @Get()
    async def get(self) -> str:
        return await self.service.get()

    @Post()
    async def post(self, data: Annotated[dict, Body()]) -> str:
        return await self.service.post(data=data)

    @Put("/{app_id}")
    async def put(
        self, app_id: Annotated[int, Param("app_id")], data: Annotated[dict, Body()]
    ) -> str:
        return await self.service.put(id_=app_id, data=data)

    @Delete("/{app_id}")
    async def delete(self, app_id: Annotated[int, Param("app_id")]) -> None:
        await self.service.delete(id_=app_id)

And, for app_service.py

from nestipy.common import Injectable


@Injectable()
class AppService:
    @classmethod
    async def get(cls):
        return "test"

    @classmethod
    async def post(cls, data: dict):
        return "test"

    @classmethod
    async def put(cls, id_: int, data: dict):
        return "test"

    @classmethod
    async def delete(cls, id_: int):
        return "test"

Typed TypeScript Client

Generate a typed TypeScript HTTP client straight from your controllers so any JS/TS frontend can call your API with full typing:

nestipy run client:gen --output clients/api_client.ts --class ApiClient

import { createApiClient } from "./api_client";

const api = createApiClient({ baseUrl: "/api" });
const cat = await api.CatsController.getCat(1); // fully typed, grouped by controller

See Typed Client for the full guide.

Web Frontends with Inertia

For server-driven pages, Nestipy ships a first-class Inertia.js adapter (nestipy-inertia) with full protocol parity — partial reloads, deferred props, merge props, history encryption and SSR. See Inertia.

Documentation

View full documentation from here.

Support

Nestipy is an MIT-licensed open source project. It can grow thanks to the sponsors and support from the amazing backers. If you'd like to join them, please [read more here].

Stay in touch

• Author - Tsiresy Mila

License

Nestipy is MIT licensed.