nestipy

KO | EN

gitlite — search

#python #react #typescript #android #machine-learning #rust #docker #macos #nodejs #windows #vue #security #mcp #open-source

(★ 13)

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

nestipy Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

## 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 <a href="https://fastapi.tiangolo.com/" target="_blank">FastAPI</a>, but also provides compatibility with a wide range of other libraries, like <a href="https://fastapi.tiangolo.com/" target="_blank">Blacksheep</a>, allowing for easy use of the myriad of third-party plugins which are available.

## Getting started

```cmd
    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).

```python
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`):

```python
if __name__ == '__main__':
    app.listen(host="0.0.0.0", port=8000)
```
Inside module, we got,

```python
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
```python
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`
```python
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:

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

```ts
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](https://nestipy.vercel.app/overview/typed-client) for the full guide.

## Web Frontends with Inertia

For server-driven pages, Nestipy ships a first-class [Inertia.js](https://inertiajs.com)
adapter (`nestipy-inertia`) with full protocol parity — partial reloads, deferred props,
merge props, history encryption and SSR. See [Inertia](https://nestipy.vercel.app/technique/inertia).

## Documentation

View full documentation from [here](https://nestipy.vercel.app).

## 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](https://tsiresymila.vercel.app)

## License

Nestipy is [MIT licensed](LICENSE).

nestipy

nestipy Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

nestipy

nestipy Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README