Add better support for `ManyToManyField`'s `through` model #1719

flaeppe · 2023-09-17T21:42:18Z

I have made things!

I've modified how ManyToManyField is generic and also made the ManyToManyDescriptor generic. This was to get a better description of the ManyToManyField, which requires less plugin interference and results in more accurate types.

The most important thing to notice here is a call without any explicit through argument makes the ManyToManyField instance only partially declared. This is where the plugin steps in and will detect the call argument is missing and generate a through model definition that aligns with what Django describes under the ManyToManyField.through section in their documentation. Here: https://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.ManyToManyField.through.

ManyToManyField.through should now be properly resolved to either an implicitly generated through model, or an explicitly passed one. For example, expanding a generated through model looks like below:

class MyModel_m2mfield(models.Model):
    id: <DefaultAutoField>
    mymodel: ForeignKey(MyModel)
    mymodel_id: MyModel.pk
    othermodel: ForeignKey(OtherModel)
    othermodel_id: OtherModel.pk

    objects: models.Manager["MyModel_m2mfield"]

ManyToManyField() calls with lazy references (e.g. "myapp.MyModel") should also be supported, "self" too.

Related issues

Closes: #1549
Closes: #883
Refs: #1638
Refs: #1454

An additional note here is that I'm getting a feeling that the there's a similar adjustment to be done for e.g. ForeignKey and OneToOneField and their descriptors, which could improve their definition in general, while requiring less plugin code.

sobolevn

This is not a full review, just some questions.

Thanks for your work!

sobolevn · 2023-09-18T07:16:22Z

django-stubs/db/models/fields/related.pyi


+class ManyToManyField(RelatedField[Any, Any], Generic[_To, _M]):


Can we make it generic on all the things and simplify our plugin a bit?

Which parts are you referring to?

The plugin only acts on what is _T and _M here, essentially the to= and through= argument on ManyToManyField.

It does however have to sort some stuff out when there was no explicit through= argument passed, as Django automatically generates a through model behind the scenes in that case.

Additionally it supports resolving lazy references e.g. "myapp.MyModel" and replaces either _T or _M with any found model type.

Which parts are you referring to?

What I meant to say here was: which other parts should we make generic to simplify the plugin?

_GT, _ST? Will it help?

No, this changes so that those arguments aren't used at all any more, for ManyToManyField. It's just the parent class that wants them.

The generics of the descriptor class does almost all the work now instead (except when through is implicit, then the plugin does that part)

It's a bit hard to follow, but instead of using _GT and _ST and let our plugin do all the work, I've updated the descriptor class ManyToManyDescriptor to become generic over a model, and that will be the through= model for a ManyToManyField().

And if you now look a bit further, you find: ManyToManyDescriptor.through -> type[_M] which means that the through= argument align with the MyModel.m2m_field.through without any plugin work (again, except for special cases of lazy referencing or not passing the through= argument, which is all the new plugin code you see in this PR)

Corresponding part is the to= argument, plugin code will only be running for lazy referencing. Previously this was completely managed by the plugin, now it's instead mypy doing the work.

mypy_django_plugin/lib/helpers.py