An equivalent for fastapi.Depends

[remimd]

Hello,

Usually I work with FastAPI but I recently started a new personal project with django-ninja because I needed an administration interface quickly.

I quickly realized that I was missing an equivalent to fastapi.Depends which is a very efficient tool for factoring code.
I think it would also be a good entry point to facilitate library integration into django-ninja.

I wanted to know if I'd missed anything in the documentation or if there were strategies I didn't know about to achieve this.

I'm curious to hear your opinion on this.

[vitalik]

@remimd what would you put to Depends ?

[remimd]

If you think it's unnecessary and I'm the only one who needs it, I'm not going to be picky.

Here are two simple examples I've found that could be useful in everyday life:

• Building objects with multiple data from the request:

from dataclasses import dataclass

@dataclass
class LimitAndOffset:
    limit: int
    offset: int

def get_limit_and_offset(page: int = 1, per_page: int = 20) -> LimitAndOffset:
    return LimitAndOffset(
        limit=per_page,
        offset=per_page * (page - 1),
    )

• Retrieve resources directly:

async def get_cat(cat_id: int) -> Cat:
    return await Cat.objects.aget(id=cat_id)

You might think that this kind of thing is superfluous, but it reduces the number of parameters and processes to be performed in the view, which can make the code more readable.

[vitalik]

@remimd

well you can already achieve this with pydantic models:

limit/offset:

from ninja import Schema, Query

class LimitAndOffset(Schema):
    limit: int
    offset: int


@api.get("/filter")
def events(request, filters: Query[LimitAndOffset]):

cat

class Cat(Schema):
    cat_id: int
    
    @model_validate
    def get_cat(...)


@api.get("/filter")
def events(request, cat: Query[Cat]):
     ...

I'm not trying to be picky but decision to avoid "dependency" injection they way it was done in fastapi was intentional (because simply starlet/fastpi lack infrastructure that was built on top of django that allowed to achive lot of thigns)

I'm not strongly against some Depend annotator - just trying to design a system so that all users have an easy way to pick the right tool for the job avoiding multiple options

[remimd]

Sorry, I don't know django-ninja well enough yet. Indeed, if it's already possible to do this kind of thing, Depends isn't really useful.

[remimd]

To come back to my initial need, I did a little research on how other people.

• django-ninja-extra has a controller system where dependency injection is done at the __init__ method level.
• anydi patches ViewSignature, Operation and AsyncOperation to achieve this.

But these two methods don't really appeal to me.

[remimd]

To conclude with Depends, I don't have any further arguments to convince you. Maybe others in the future will have more concrete needs that support its adoption.

[maldoinc]

A bit of a shameless self-promotion here, but @remimd If you're still looking for Dependency Injection in Django Ninja, you might want to check out wireup. It has a Django integration that lets you inject services directly into your views using type hints.

from ninja import Router, Schema
from wireup import Injected
from wireup.integration.django import inject

router = Router()

@router.get("/items")
@inject
def list_items(request, s3_manager: Injected[S3Manager]):
    # s3_manager is fully wired with its own dependencies
    return s3_manager.list_objects()

@router.post("/items")
@inject
def create_item(request, payload: ItemSchema, s3_manager: Injected[S3Manager]):
    s3_manager.upload(payload.dict())
    return {"success": True}

[remimd]

Thanks @maldoinc for the suggestion! I actually use my own DI package (python-injection). My initial motivation for this discussion was to find a clean way to build a django-ninja integration for it, but I couldn't find a proper way to do so and gave up. Also, I'm currently moving away from Django as its type annotation support is quite limited.