plain.models 0.49.2__py3-none-any.whl → 0.51.0__py3-none-any.whl

plain/models/fields/related.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 from functools import cached_property, partial
+from typing import TYPE_CHECKING, Any
 
 from plain import exceptions
 from plain.models.constants import LOOKUP_SEP
@@ -30,10 +33,16 @@ from .related_lookups import (
 )
 from .reverse_related import ManyToManyRel, ManyToOneRel
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+    from plain.models.base import Model
+
 RECURSIVE_RELATIONSHIP_CONSTANT = "self"
 
 
-def resolve_relation(scope_model, relation):
+def resolve_relation(
+    scope_model: type[Model], relation: type[Model] | str
+) -> type[Model] | str:
     """
     Transform relation into a model or fully-qualified model string of the form
     "package_label.ModelName", relative to scope_model.
@@ -53,12 +62,14 @@ def resolve_relation(scope_model, relation):
     # Look for an "app.Model" relation
     if isinstance(relation, str):
         if "." not in relation:
-            relation = f"{scope_model._meta.package_label}.{relation}"
+            relation = f"{scope_model.model_options.package_label}.{relation}"
 
     return relation
 
 
-def lazy_related_operation(function, model, *related_models, **kwargs):
+def lazy_related_operation(
+    function: Any, model: type[Model], *related_models: type[Model] | str, **kwargs: Any
+) -> None:
     """
     Schedule `function` to be called once `model` and all `related_models`
     have been imported and registered with the app registry. `function` will
@@ -71,11 +82,11 @@ def lazy_related_operation(function, model, *related_models, **kwargs):
     references will be resolved relative to `model`.
 
     This is a convenience wrapper for `Packages.lazy_model_operation` - the app
-    registry model used is the one found in `model._meta.models_registry`.
+    registry model used is the one found in `model._model_meta.models_registry`.
     """
     models = [model] + [resolve_relation(model, rel) for rel in related_models]
     model_keys = (make_model_tuple(m) for m in models)
-    models_registry = model._meta.models_registry
+    models_registry = model._model_meta.models_registry
     return models_registry.lazy_model_operation(
         partial(function, **kwargs), *model_keys
     )
@@ -92,35 +103,35 @@ class RelatedField(FieldCacheMixin, Field):
     def __init__(
         self,
         *,
-        related_name=None,
-        related_query_name=None,
-        limit_choices_to=None,
-        **kwargs,
+        related_name: str | None = None,
+        related_query_name: str | None = None,
+        limit_choices_to: Any = None,
+        **kwargs: Any,
     ):
         self._related_name = related_name
         self._related_query_name = related_query_name
         self._limit_choices_to = limit_choices_to
-        super().__init__(**kwargs)
+        super().__init__(**kwargs)  # type: ignore[misc]
 
     @cached_property
-    def related_model(self):
+    def related_model(self) -> type[Model]:
         # Can't cache this property until all the models are loaded.
         models_registry.check_ready()
-        return self.remote_field.model
+        return self.remote_field.model  # type: ignore[attr-defined]
 
-    def preflight(self, **kwargs):
+    def preflight(self, **kwargs: Any) -> list[PreflightResult]:  # type: ignore[misc]
         return [
-            *super().preflight(**kwargs),
+            *super().preflight(**kwargs),  # type: ignore[misc]
             *self._check_related_name_is_valid(),
             *self._check_related_query_name_is_valid(),
             *self._check_relation_model_exists(),
             *self._check_clashes(),
         ]
 
-    def _check_related_name_is_valid(self):
+    def _check_related_name_is_valid(self) -> list[PreflightResult]:
         import keyword
 
-        related_name = self.remote_field.related_name
+        related_name = self.remote_field.related_name  # type: ignore[attr-defined]
         if related_name is None:
             return []
         is_valid_id = (
@@ -129,18 +140,18 @@ class RelatedField(FieldCacheMixin, Field):
         if not is_valid_id:
             return [
                 PreflightResult(
-                    fix=f"The name '{self.remote_field.related_name}' is invalid related_name for field {self.model._meta.object_name}.{self.name}. Related name must be a valid Python identifier.",
+                    fix=f"The name '{self.remote_field.related_name}' is invalid related_name for field {self.model.model_options.object_name}.{self.name}. Related name must be a valid Python identifier.",
                     obj=self,
                     id="fields.invalid_related_name",
                 )
             ]
         return []
 
-    def _check_related_query_name_is_valid(self):
-        if self.remote_field.is_hidden():
+    def _check_related_query_name_is_valid(self) -> list[PreflightResult]:
+        if self.remote_field.is_hidden():  # type: ignore[attr-defined]
             return []
         rel_query_name = self.related_query_name()
-        errors = []
+        errors: list[PreflightResult] = []
         if rel_query_name.endswith("_"):
             errors.append(
                 PreflightResult(
@@ -167,15 +178,15 @@ class RelatedField(FieldCacheMixin, Field):
             )
         return errors
 
-    def _check_relation_model_exists(self):
+    def _check_relation_model_exists(self) -> list[PreflightResult]:
         rel_is_missing = (
-            self.remote_field.model not in self.opts.models_registry.get_models()
+            self.remote_field.model not in self.meta.models_registry.get_models()  # type: ignore[attr-defined]
         )
-        rel_is_string = isinstance(self.remote_field.model, str)
+        rel_is_string = isinstance(self.remote_field.model, str)  # type: ignore[attr-defined]
         model_name = (
-            self.remote_field.model
+            self.remote_field.model  # type: ignore[attr-defined]
             if rel_is_string
-            else self.remote_field.model._meta.object_name
+            else self.remote_field.model.model_options.object_name
         )
         if rel_is_missing and rel_is_string:
             return [
@@ -190,16 +201,15 @@ class RelatedField(FieldCacheMixin, Field):
             ]
         return []
 
-    def _check_clashes(self):
+    def _check_clashes(self) -> list[PreflightResult]:
         """Check accessor and reverse query name clashes."""
         from plain.models.base import ModelBase
 
-        errors = []
-        opts = self.model._meta
+        errors: list[PreflightResult] = []
 
         # f.remote_field.model may be a string instead of a model. Skip if
         # model name is not resolved.
-        if not isinstance(self.remote_field.model, ModelBase):
+        if not isinstance(self.remote_field.model, ModelBase):  # type: ignore[attr-defined]
             return []
 
         # Consider that we are checking field `Model.foreign` and the models
@@ -213,29 +223,32 @@ class RelatedField(FieldCacheMixin, Field):
         #         foreign = models.ForeignKey(Target)
         #         m2m = models.ManyToManyField(Target)
 
-        # rel_opts.object_name == "Target"
-        rel_opts = self.remote_field.model._meta
+        # rel_options.object_name == "Target"
+        rel_meta = self.remote_field.model._model_meta
+        rel_options = self.remote_field.model.model_options
         # If the field doesn't install a backward relation on the target model
         # (so `is_hidden` returns True), then there are no clashes to check
         # and we can skip these fields.
-        rel_is_hidden = self.remote_field.is_hidden()
-        rel_name = self.remote_field.get_accessor_name()  # i. e. "model_set"
+        rel_is_hidden = self.remote_field.is_hidden()  # type: ignore[attr-defined]
+        rel_name = (
+            self.remote_field.get_accessor_name()
+        )  # i. e. "model_set"  # type: ignore[attr-defined]
         rel_query_name = self.related_query_name()  # i. e. "model"
         # i.e. "package_label.Model.field".
-        field_name = f"{opts.label}.{self.name}"
+        field_name = f"{self.model.model_options.label}.{self.name}"
 
         # Check clashes between accessor or reverse query name of `field`
         # and any other field name -- i.e. accessor for Model.foreign is
         # model_set and it clashes with Target.model_set.
-        potential_clashes = rel_opts.fields + rel_opts.many_to_many
+        potential_clashes = rel_meta.fields + rel_meta.many_to_many
         for clash_field in potential_clashes:
             # i.e. "package_label.Target.model_set".
-            clash_name = f"{rel_opts.label}.{clash_field.name}"
+            clash_name = f"{rel_options.label}.{clash_field.name}"
             if not rel_is_hidden and clash_field.name == rel_name:
                 errors.append(
                     PreflightResult(
                         fix=(
-                            f"Reverse accessor '{rel_opts.object_name}.{rel_name}' "
+                            f"Reverse accessor '{rel_options.object_name}.{rel_name}' "
                             f"for '{field_name}' clashes with field name "
                             f"'{clash_name}'. "
                             f"Rename field '{clash_name}', or add/change a related_name "
@@ -262,17 +275,15 @@ class RelatedField(FieldCacheMixin, Field):
         # Check clashes between accessors/reverse query names of `field` and
         # any other field accessor -- i. e. Model.foreign accessor clashes with
         # Model.m2m accessor.
-        potential_clashes = (r for r in rel_opts.related_objects if r.field is not self)
+        potential_clashes = (r for r in rel_meta.related_objects if r.field is not self)
         for clash_field in potential_clashes:
             # i.e. "package_label.Model.m2m".
-            clash_name = (
-                f"{clash_field.related_model._meta.label}.{clash_field.field.name}"
-            )
+            clash_name = f"{clash_field.related_model.model_options.label}.{clash_field.field.name}"
             if not rel_is_hidden and clash_field.get_accessor_name() == rel_name:
                 errors.append(
                     PreflightResult(
                         fix=(
-                            f"Reverse accessor '{rel_opts.object_name}.{rel_name}' "
+                            f"Reverse accessor '{rel_options.object_name}.{rel_name}' "
                             f"for '{field_name}' clashes with reverse accessor for "
                             f"'{clash_name}'. "
                             "Add or change a related_name argument "
@@ -299,42 +310,47 @@ class RelatedField(FieldCacheMixin, Field):
 
         return errors
 
-    def db_type(self, connection):
+    def db_type(self, connection: BaseDatabaseWrapper) -> None:
         # By default related field will not have a column as it relates to
         # columns from another table.
         return None
 
-    def contribute_to_class(self, cls, name):
-        super().contribute_to_class(cls, name)
+    def contribute_to_class(self, cls: type[Model], name: str) -> None:
+        super().contribute_to_class(cls, name)  # type: ignore[misc]
 
-        self.opts = cls._meta
+        self.meta = cls._model_meta
 
-        if self.remote_field.related_name:
-            related_name = self.remote_field.related_name
+        if self.remote_field.related_name:  # type: ignore[attr-defined]
+            related_name = self.remote_field.related_name  # type: ignore[attr-defined]
             related_name %= {
                 "class": cls.__name__.lower(),
-                "model_name": cls._meta.model_name.lower(),
-                "package_label": cls._meta.package_label.lower(),
+                "model_name": cls.model_options.model_name.lower(),
+                "package_label": cls.model_options.package_label.lower(),
             }
-            self.remote_field.related_name = related_name
+            self.remote_field.related_name = related_name  # type: ignore[attr-defined]
 
-        if self.remote_field.related_query_name:
-            related_query_name = self.remote_field.related_query_name % {
+        if self.remote_field.related_query_name:  # type: ignore[attr-defined]
+            related_query_name = self.remote_field.related_query_name % {  # type: ignore[attr-defined]
                 "class": cls.__name__.lower(),
-                "package_label": cls._meta.package_label.lower(),
+                "package_label": cls.model_options.package_label.lower(),
             }
-            self.remote_field.related_query_name = related_query_name
+            self.remote_field.related_query_name = related_query_name  # type: ignore[attr-defined]
 
-        def resolve_related_class(model, related, field):
-            field.remote_field.model = related
+        def resolve_related_class(
+            model: type[Model], related: type[Model], field: RelatedField
+        ) -> None:
+            field.remote_field.model = related  # type: ignore[attr-defined]
             field.do_related_class(related, model)
 
         lazy_related_operation(
-            resolve_related_class, cls, self.remote_field.model, field=self
+            resolve_related_class,
+            cls,
+            self.remote_field.model,
+            field=self,  # type: ignore[attr-defined]
         )
 
-    def deconstruct(self):
-        name, path, args, kwargs = super().deconstruct()
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
+        name, path, args, kwargs = super().deconstruct()  # type: ignore[misc]
         if self._limit_choices_to:
             kwargs["limit_choices_to"] = self._limit_choices_to
         if self._related_name is not None:
@@ -343,7 +359,7 @@ class RelatedField(FieldCacheMixin, Field):
             kwargs["related_query_name"] = self._related_query_name
         return name, path, args, kwargs
 
-    def get_forward_related_filter(self, obj):
+    def get_forward_related_filter(self, obj: Model) -> dict[str, Any]:
         """
         Return the keyword arguments that when supplied to
         self.model.object.filter(), would select all instances related through
@@ -353,10 +369,10 @@ class RelatedField(FieldCacheMixin, Field):
         """
         return {
             f"{self.name}__{rh_field.name}": getattr(obj, rh_field.attname)
-            for _, rh_field in self.related_fields
+            for _, rh_field in self.related_fields  # type: ignore[attr-defined]
         }
 
-    def get_reverse_related_filter(self, obj):
+    def get_reverse_related_filter(self, obj: Model) -> Any:
         """
         Complement to get_forward_related_filter(). Return the keyword
         arguments that when passed to self.related_field.model.object.filter()
@@ -366,47 +382,49 @@ class RelatedField(FieldCacheMixin, Field):
         return Q.create(
             [
                 (rh_field.attname, getattr(obj, lh_field.attname))
-                for lh_field, rh_field in self.related_fields
+                for lh_field, rh_field in self.related_fields  # type: ignore[attr-defined]
             ]
         )
 
-    def set_attributes_from_rel(self):
-        self.name = self.name or (self.remote_field.model._meta.model_name + "_" + "id")
-        self.remote_field.set_field_name()
+    def set_attributes_from_rel(self) -> None:
+        self.name = self.name or (
+            self.remote_field.model.model_options.model_name + "_" + "id"
+        )
+        self.remote_field.set_field_name()  # type: ignore[attr-defined]
 
-    def do_related_class(self, other, cls):
+    def do_related_class(self, other: type[Model], cls: type[Model]) -> None:
         self.set_attributes_from_rel()
-        self.contribute_to_related_class(other, self.remote_field)
+        self.contribute_to_related_class(other, self.remote_field)  # type: ignore[attr-defined]
 
-    def get_limit_choices_to(self):
+    def get_limit_choices_to(self) -> Any:
         """
         Return ``limit_choices_to`` for this model field.
 
         If it is a callable, it will be invoked and the result will be
         returned.
         """
-        if callable(self.remote_field.limit_choices_to):
-            return self.remote_field.limit_choices_to()
-        return self.remote_field.limit_choices_to
+        if callable(self.remote_field.limit_choices_to):  # type: ignore[attr-defined]
+            return self.remote_field.limit_choices_to()  # type: ignore[attr-defined]
+        return self.remote_field.limit_choices_to  # type: ignore[attr-defined]
 
-    def related_query_name(self):
+    def related_query_name(self) -> str:
         """
         Define the name that can be used to identify this related object in a
         table-spanning query.
         """
         return (
-            self.remote_field.related_query_name
-            or self.remote_field.related_name
-            or self.opts.model_name
+            self.remote_field.related_query_name  # type: ignore[attr-defined]
+            or self.remote_field.related_name  # type: ignore[attr-defined]
+            or self.model.model_options.model_name  # type: ignore[attr-defined]
         )
 
     @property
-    def target_field(self):
+    def target_field(self) -> Field:
         """
         When filtering against this relation, return the field on the remote
         model against which the filtering should happen.
         """
-        target_fields = self.path_infos[-1].target_fields
+        target_fields = self.path_infos[-1].target_fields  # type: ignore[attr-defined]
         if len(target_fields) > 1:
             raise FieldError(
                 "The relation has multiple target fields, but only single target field "
@@ -414,8 +432,8 @@ class RelatedField(FieldCacheMixin, Field):
             )
         return target_fields[0]
 
-    def get_cache_name(self):
-        return self.name
+    def get_cache_name(self) -> str:
+        return self.name  # type: ignore[return-value]
 
 
 class ForeignKey(RelatedField):
@@ -442,19 +460,19 @@ class ForeignKey(RelatedField):
 
     def __init__(
         self,
-        to,
-        on_delete,
-        related_name=None,
-        related_query_name=None,
-        limit_choices_to=None,
-        db_index=True,
-        db_constraint=True,
-        **kwargs,
+        to: type[Model] | str,
+        on_delete: Any,
+        related_name: str | None = None,
+        related_query_name: str | None = None,
+        limit_choices_to: Any = None,
+        db_index: bool = True,
+        db_constraint: bool = True,
+        **kwargs: Any,
     ):
-        try:
-            to._meta.model_name
-        except AttributeError:
-            if not isinstance(to, str):
+        if not isinstance(to, str):
+            try:
+                to.model_options.model_name
+            except AttributeError:
                 raise TypeError(
                     f"{self.__class__.__name__}({to!r}) is invalid. First parameter to ForeignKey must be "
                     f"either a model, a model name, or the string {RECURSIVE_RELATIONSHIP_CONSTANT!r}"
@@ -481,55 +499,57 @@ class ForeignKey(RelatedField):
         self.db_index = db_index
         self.db_constraint = db_constraint
 
-    def __copy__(self):
-        obj = super().__copy__()
+    def __copy__(self) -> ForeignKey:
+        obj = super().__copy__()  # type: ignore[misc]
         # Remove any cached PathInfo values.
         obj.__dict__.pop("path_infos", None)
         obj.__dict__.pop("reverse_path_infos", None)
         return obj
 
     @cached_property
-    def related_fields(self):
+    def related_fields(self) -> list[tuple[Field, Field]]:
         return self.resolve_related_fields()
 
     @cached_property
-    def reverse_related_fields(self):
+    def reverse_related_fields(self) -> list[tuple[Field, Field]]:
         return [(rhs_field, lhs_field) for lhs_field, rhs_field in self.related_fields]
 
     @cached_property
-    def local_related_fields(self):
+    def local_related_fields(self) -> tuple[Field, ...]:
         return tuple(lhs_field for lhs_field, rhs_field in self.related_fields)
 
     @cached_property
-    def foreign_related_fields(self):
+    def foreign_related_fields(self) -> tuple[Field, ...]:
         return tuple(
             rhs_field for lhs_field, rhs_field in self.related_fields if rhs_field
         )
 
-    def get_local_related_value(self, instance):
+    def get_local_related_value(self, instance: Model) -> tuple[Any, ...]:
         # Always returns the value of the single local field
         field = self.local_related_fields[0]
-        if field.primary_key:
+        if field.primary_key:  # type: ignore[attr-defined]
             return (instance.id,)
-        return (getattr(instance, field.attname),)
+        return (getattr(instance, field.attname),)  # type: ignore[attr-defined]
 
-    def get_foreign_related_value(self, instance):
+    def get_foreign_related_value(self, instance: Model) -> tuple[Any, ...]:
         # Always returns the id of the foreign instance
         return (instance.id,)
 
-    def get_joining_columns(self, reverse_join=False):
+    def get_joining_columns(
+        self, reverse_join: bool = False
+    ) -> tuple[tuple[str, str], ...]:
         # Always returns a single column pair
         if reverse_join:
             from_field, to_field = self.related_fields[0]
-            return ((to_field.column, from_field.column),)
+            return ((to_field.column, from_field.column),)  # type: ignore[attr-defined]
         else:
             from_field, to_field = self.related_fields[0]
-            return ((from_field.column, to_field.column),)
+            return ((from_field.column, to_field.column),)  # type: ignore[attr-defined]
 
-    def get_reverse_joining_columns(self):
+    def get_reverse_joining_columns(self) -> tuple[tuple[str, str], ...]:
         return self.get_joining_columns(reverse_join=True)
 
-    def get_extra_restriction(self, alias, related_alias):
+    def get_extra_restriction(self, alias: str, related_alias: str) -> None:
         """
         Return a pair condition used for joining and subquery pushdown. The
         condition is something that responds to as_sql(compiler, connection)
@@ -543,14 +563,14 @@ class ForeignKey(RelatedField):
         """
         return None
 
-    def get_path_info(self, filtered_relation=None):
+    def get_path_info(self, filtered_relation: Any = None) -> list[PathInfo]:
         """Get path from this field to the related model."""
-        opts = self.remote_field.model._meta
-        from_opts = self.model._meta
+        meta = self.remote_field.model._model_meta
+        from_meta = self.model._model_meta
         return [
             PathInfo(
-                from_opts=from_opts,
-                to_opts=opts,
+                from_meta=from_meta,
+                to_meta=meta,
                 target_fields=self.foreign_related_fields,
                 join_field=self,
                 m2m=False,
@@ -560,58 +580,58 @@ class ForeignKey(RelatedField):
         ]
 
     @cached_property
-    def path_infos(self):
+    def path_infos(self) -> list[PathInfo]:
         return self.get_path_info()
 
-    def get_reverse_path_info(self, filtered_relation=None):
+    def get_reverse_path_info(self, filtered_relation: Any = None) -> list[PathInfo]:
         """Get path from the related model to this field's model."""
-        opts = self.model._meta
-        from_opts = self.remote_field.model._meta
+        meta = self.model._model_meta
+        from_meta = self.remote_field.model._model_meta
         return [
             PathInfo(
-                from_opts=from_opts,
-                to_opts=opts,
-                target_fields=(opts.get_field("id"),),
-                join_field=self.remote_field,
-                m2m=not self.primary_key,
+                from_meta=from_meta,
+                to_meta=meta,
+                target_fields=(meta.get_field("id"),),
+                join_field=self.remote_field,  # type: ignore[attr-defined]
+                m2m=not self.primary_key,  # type: ignore[attr-defined]
                 direct=False,
                 filtered_relation=filtered_relation,
             )
         ]
 
     @cached_property
-    def reverse_path_infos(self):
+    def reverse_path_infos(self) -> list[PathInfo]:
         return self.get_reverse_path_info()
 
-    def contribute_to_class(self, cls, name):
+    def contribute_to_class(self, cls: type[Model], name: str) -> None:
         super().contribute_to_class(cls, name)
-        setattr(cls, self.name, self.forward_related_accessor_class(self))
+        setattr(cls, self.name, self.forward_related_accessor_class(self))  # type: ignore[attr-defined]
 
-    def contribute_to_related_class(self, cls, related):
+    def contribute_to_related_class(self, cls: type[Model], related: Any) -> None:
         # Internal FK's - i.e., those with a related name ending with '+'
-        if not self.remote_field.is_hidden():
+        if not self.remote_field.is_hidden():  # type: ignore[attr-defined]
             setattr(
                 cls,
                 related.get_accessor_name(),
-                self.related_accessor_class(related),
+                self.related_accessor_class(related),  # type: ignore[attr-defined]
             )
             # While 'limit_choices_to' might be a callable, simply pass
             # it along for later - this is too early because it's still
             # model load time.
-            if self.remote_field.limit_choices_to:
-                cls._meta.related_fkey_lookups.append(
-                    self.remote_field.limit_choices_to
+            if self.remote_field.limit_choices_to:  # type: ignore[attr-defined]
+                cls._model_meta.related_fkey_lookups.append(
+                    self.remote_field.limit_choices_to  # type: ignore[attr-defined]
                 )
 
-    def preflight(self, **kwargs):
+    def preflight(self, **kwargs: Any) -> list[PreflightResult]:  # type: ignore[misc]
         return [
-            *super().preflight(**kwargs),
+            *super().preflight(**kwargs),  # type: ignore[misc]
             *self._check_on_delete(),
         ]
 
-    def _check_on_delete(self):
-        on_delete = getattr(self.remote_field, "on_delete", None)
-        if on_delete == SET_NULL and not self.allow_null:
+    def _check_on_delete(self) -> list[PreflightResult]:
+        on_delete = getattr(self.remote_field, "on_delete", None)  # type: ignore[attr-defined]
+        if on_delete == SET_NULL and not self.allow_null:  # type: ignore[attr-defined]
             return [
                 PreflightResult(
                     fix=(
@@ -622,7 +642,7 @@ class ForeignKey(RelatedField):
                     id="fields.foreign_key_null_constraint_violation",
                 )
             ]
-        elif on_delete == SET_DEFAULT and not self.has_default():
+        elif on_delete == SET_DEFAULT and not self.has_default():  # type: ignore[attr-defined]
             return [
                 PreflightResult(
                     fix=(
@@ -636,20 +656,20 @@ class ForeignKey(RelatedField):
         else:
             return []
 
-    def deconstruct(self):
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         name, path, args, kwargs = super().deconstruct()
-        kwargs["on_delete"] = self.remote_field.on_delete
+        kwargs["on_delete"] = self.remote_field.on_delete  # type: ignore[attr-defined]
 
-        if isinstance(self.remote_field.model, SettingsReference):
-            kwargs["to"] = self.remote_field.model
-        elif isinstance(self.remote_field.model, str):
-            if "." in self.remote_field.model:
-                package_label, model_name = self.remote_field.model.split(".")
+        if isinstance(self.remote_field.model, SettingsReference):  # type: ignore[attr-defined]
+            kwargs["to"] = self.remote_field.model  # type: ignore[attr-defined]
+        elif isinstance(self.remote_field.model, str):  # type: ignore[attr-defined]
+            if "." in self.remote_field.model:  # type: ignore[attr-defined]
+                package_label, model_name = self.remote_field.model.split(".")  # type: ignore[attr-defined]
                 kwargs["to"] = f"{package_label}.{model_name.lower()}"
             else:
-                kwargs["to"] = self.remote_field.model.lower()
+                kwargs["to"] = self.remote_field.model.lower()  # type: ignore[attr-defined]
         else:
-            kwargs["to"] = self.remote_field.model._meta.label_lower
+            kwargs["to"] = self.remote_field.model.model_options.label_lower
 
         if self.db_index is not True:
             kwargs["db_index"] = self.db_index
@@ -659,105 +679,107 @@ class ForeignKey(RelatedField):
 
         return name, path, args, kwargs
 
-    def to_python(self, value):
-        return self.target_field.to_python(value)
+    def to_python(self, value: Any) -> Any:
+        return self.target_field.to_python(value)  # type: ignore[attr-defined]
 
     @property
-    def target_field(self):
+    def target_field(self) -> Field:
         return self.foreign_related_fields[0]
 
-    def validate(self, value, model_instance):
-        super().validate(value, model_instance)
+    def validate(self, value: Any, model_instance: Model) -> None:
+        super().validate(value, model_instance)  # type: ignore[misc]
         if value is None:
-            return
+            return None
 
-        qs = self.remote_field.model._meta.base_queryset.filter(
-            **{self.remote_field.field_name: value}
+        qs = self.remote_field.model._model_meta.base_queryset.filter(
+            **{self.remote_field.field_name: value}  # type: ignore[attr-defined]
         )
         qs = qs.complex_filter(self.get_limit_choices_to())
         if not qs.exists():
             raise exceptions.ValidationError(
-                self.error_messages["invalid"],
+                self.error_messages["invalid"],  # type: ignore[attr-defined]
                 code="invalid",
                 params={
-                    "model": self.remote_field.model._meta.model_name,
+                    "model": self.remote_field.model.model_options.model_name,
                     "id": value,
-                    "field": self.remote_field.field_name,
+                    "field": self.remote_field.field_name,  # type: ignore[attr-defined]
                     "value": value,
                 },
             )
 
-    def resolve_related_fields(self):
-        if isinstance(self.remote_field.model, str):
+    def resolve_related_fields(self) -> list[tuple[ForeignKey, Field]]:
+        if isinstance(self.remote_field.model, str):  # type: ignore[attr-defined]
             raise ValueError(
-                f"Related model {self.remote_field.model!r} cannot be resolved"
+                f"Related model {self.remote_field.model!r} cannot be resolved"  # type: ignore[attr-defined]
             )
         from_field = self
-        to_field = self.remote_field.model._meta.get_field("id")
-        related_fields = [(from_field, to_field)]
+        to_field = self.remote_field.model._model_meta.get_field("id")
+        related_fields: list[tuple[ForeignKey, Field]] = [(from_field, to_field)]
 
         for from_field, to_field in related_fields:
-            if to_field and to_field.model != self.remote_field.model:
+            if to_field and to_field.model != self.remote_field.model:  # type: ignore[attr-defined]
                 raise FieldError(
-                    f"'{self.model._meta.label}.{self.name}' refers to field '{to_field.name}' which is not local to model "
-                    f"'{self.remote_field.model._meta.label}'."
+                    f"'{self.model.model_options.label}.{self.name}' refers to field '{to_field.name}' which is not local to model "
+                    f"'{self.remote_field.model.model_options.label}'."
                 )
         return related_fields
 
-    def get_attname(self):
+    def get_attname(self) -> str:
         return f"{self.name}_id"
 
-    def get_attname_column(self):
+    def get_attname_column(self) -> tuple[str, str]:
         attname = self.get_attname()
-        column = self.db_column or attname
+        column = self.db_column or attname  # type: ignore[attr-defined]
         return attname, column
 
-    def get_default(self):
+    def get_default(self) -> Any:
         """Return the to_field if the default value is an object."""
-        field_default = super().get_default()
-        if isinstance(field_default, self.remote_field.model):
-            return getattr(field_default, self.target_field.attname)
+        field_default = super().get_default()  # type: ignore[misc]
+        if isinstance(field_default, self.remote_field.model):  # type: ignore[attr-defined]
+            return getattr(field_default, self.target_field.attname)  # type: ignore[attr-defined]
         return field_default
 
-    def get_db_prep_save(self, value, connection):
+    def get_db_prep_save(self, value: Any, connection: BaseDatabaseWrapper) -> Any:
         if value is None or (
-            value == "" and not self.target_field.empty_strings_allowed
+            value == "" and not self.target_field.empty_strings_allowed  # type: ignore[attr-defined]
         ):
             return None
         else:
-            return self.target_field.get_db_prep_save(value, connection=connection)
+            return self.target_field.get_db_prep_save(value, connection=connection)  # type: ignore[attr-defined]
 
-    def get_db_prep_value(self, value, connection, prepared=False):
-        return self.target_field.get_db_prep_value(value, connection, prepared)
+    def get_db_prep_value(
+        self, value: Any, connection: BaseDatabaseWrapper, prepared: bool = False
+    ) -> Any:
+        return self.target_field.get_db_prep_value(value, connection, prepared)  # type: ignore[attr-defined]
 
-    def get_prep_value(self, value):
-        return self.target_field.get_prep_value(value)
+    def get_prep_value(self, value: Any) -> Any:
+        return self.target_field.get_prep_value(value)  # type: ignore[attr-defined]
 
-    def db_check(self, connection):
+    def db_check(self, connection: BaseDatabaseWrapper) -> None:
         return None
 
-    def db_type(self, connection):
-        return self.target_field.rel_db_type(connection=connection)
+    def db_type(self, connection: BaseDatabaseWrapper) -> str | None:
+        return self.target_field.rel_db_type(connection=connection)  # type: ignore[attr-defined]
 
-    def cast_db_type(self, connection):
-        return self.target_field.cast_db_type(connection=connection)
+    def cast_db_type(self, connection: BaseDatabaseWrapper) -> str | None:
+        return self.target_field.cast_db_type(connection=connection)  # type: ignore[attr-defined]
 
-    def db_parameters(self, connection):
-        target_db_parameters = self.target_field.db_parameters(connection)
+    def db_parameters(self, connection: BaseDatabaseWrapper) -> dict[str, Any]:
+        target_db_parameters = self.target_field.db_parameters(connection)  # type: ignore[attr-defined]
         return {
             "type": self.db_type(connection),
             "check": self.db_check(connection),
             "collation": target_db_parameters.get("collation"),
         }
 
-    def get_col(self, alias, output_field=None):
+    def get_col(self, alias: str, output_field: Field | None = None) -> Any:
         if output_field is None:
             output_field = self.target_field
             while isinstance(output_field, ForeignKey):
                 output_field = output_field.target_field
                 if output_field is self:
                     raise ValueError("Cannot resolve output_field.")
-        return super().get_col(alias, output_field)
+        return super().get_col(alias, output_field)  # type: ignore[misc]
 
 
 # Register lookups for ForeignKey
@@ -791,20 +813,20 @@ class ManyToManyField(RelatedField):
 
     def __init__(
         self,
-        to,
+        to: type[Model] | str,
         *,
-        through,
-        through_fields=None,
-        related_name=None,
-        related_query_name=None,
-        limit_choices_to=None,
-        symmetrical=None,
-        **kwargs,
+        through: type[Model] | str,
+        through_fields: tuple[str, str] | None = None,
+        related_name: str | None = None,
+        related_query_name: str | None = None,
+        limit_choices_to: Any = None,
+        symmetrical: bool | None = None,
+        **kwargs: Any,
     ):
-        try:
-            to._meta
-        except AttributeError:
-            if not isinstance(to, str):
+        if not isinstance(to, str):
+            try:
+                to._model_meta
+            except AttributeError:
                 raise TypeError(
                     f"{self.__class__.__name__}({to!r}) is invalid. First parameter to ManyToManyField "
                     f"must be either a model, a model name, or the string {RECURSIVE_RELATIONSHIP_CONSTANT!r}"
@@ -835,18 +857,18 @@ class ManyToManyField(RelatedField):
             **kwargs,
         )
 
-    def preflight(self, **kwargs):
+    def preflight(self, **kwargs: Any) -> list[PreflightResult]:  # type: ignore[misc]
         return [
-            *super().preflight(**kwargs),
+            *super().preflight(**kwargs),  # type: ignore[misc]
             *self._check_relationship_model(**kwargs),
             *self._check_ignored_options(**kwargs),
             *self._check_table_uniqueness(**kwargs),
         ]
 
-    def _check_ignored_options(self, **kwargs):
-        warnings = []
+    def _check_ignored_options(self, **kwargs: Any) -> list[PreflightResult]:
+        warnings: list[PreflightResult] = []
 
-        if self.has_null_arg:
+        if self.has_null_arg:  # type: ignore[attr-defined]
             warnings.append(
                 PreflightResult(
                     fix="The 'null' option has no effect on ManyToManyField. Remove the 'null' argument.",
@@ -865,7 +887,7 @@ class ManyToManyField(RelatedField):
                     warning=True,
                 )
             )
-        if self.remote_field.symmetrical and self._related_name:
+        if self.remote_field.symmetrical and self._related_name:  # type: ignore[attr-defined]
             warnings.append(
                 PreflightResult(
                     fix=(
@@ -878,7 +900,7 @@ class ManyToManyField(RelatedField):
                     warning=True,
                 )
             )
-        if self.db_comment:
+        if self.db_comment:  # type: ignore[attr-defined]
             warnings.append(
                 PreflightResult(
                     fix="The 'db_comment' option has no effect on ManyToManyField. Remove the 'db_comment' argument.",
@@ -890,15 +912,17 @@ class ManyToManyField(RelatedField):
 
         return warnings
 
-    def _check_relationship_model(self, from_model=None, **kwargs):
-        if hasattr(self.remote_field.through, "_meta"):
-            qualified_model_name = f"{self.remote_field.through._meta.package_label}.{self.remote_field.through.__name__}"
+    def _check_relationship_model(
+        self, from_model: type[Model] | None = None, **kwargs: Any
+    ) -> list[PreflightResult]:
+        if hasattr(self.remote_field.through, "_model_meta"):
+            qualified_model_name = f"{self.remote_field.through.model_options.package_label}.{self.remote_field.through.__name__}"
         else:
             qualified_model_name = self.remote_field.through
 
         errors = []
 
-        if self.remote_field.through not in self.opts.models_registry.get_models():
+        if self.remote_field.through not in self.meta.models_registry.get_models():
             # The relationship model is not installed.
             errors.append(
                 PreflightResult(
@@ -920,18 +944,20 @@ class ManyToManyField(RelatedField):
             )
             # Set some useful local variables
             to_model = resolve_relation(from_model, self.remote_field.model)
-            from_model_name = from_model._meta.object_name
+            from_model_name = from_model.model_options.object_name
             if isinstance(to_model, str):
                 to_model_name = to_model
             else:
-                to_model_name = to_model._meta.object_name
-            relationship_model_name = self.remote_field.through._meta.object_name
+                to_model_name = to_model.model_options.object_name
+            relationship_model_name = (
+                self.remote_field.through.model_options.object_name
+            )
             self_referential = from_model == to_model
             # Count foreign keys in intermediate model
             if self_referential:
                 seen_self = sum(
                     from_model == getattr(field.remote_field, "model", None)
-                    for field in self.remote_field.through._meta.fields
+                    for field in self.remote_field.through._model_meta.fields
                 )
 
                 if seen_self > 2 and not self.remote_field.through_fields:
@@ -953,11 +979,11 @@ class ManyToManyField(RelatedField):
                 # Count foreign keys in relationship model
                 seen_from = sum(
                     from_model == getattr(field.remote_field, "model", None)
-                    for field in self.remote_field.through._meta.fields
+                    for field in self.remote_field.through._model_meta.fields
                 )
                 seen_to = sum(
                     to_model == getattr(field.remote_field, "model", None)
-                    for field in self.remote_field.through._meta.fields
+                    for field in self.remote_field.through._model_meta.fields
                 )
 
                 if seen_from > 1 and not self.remote_field.through_fields:
@@ -1054,7 +1080,7 @@ class ManyToManyField(RelatedField):
                     (target_field_name, target),
                 ):
                     possible_field_names = []
-                    for f in through._meta.fields:
+                    for f in through._model_meta.fields:
                         if (
                             hasattr(f, "remote_field")
                             and getattr(f.remote_field, "model", None) == related_model
@@ -1064,7 +1090,7 @@ class ManyToManyField(RelatedField):
                         fix = (
                             "Did you mean one of the following foreign keys to '{}': "
                             "{}?".format(
-                                related_model._meta.object_name,
+                                related_model.model_options.object_name,
                                 ", ".join(possible_field_names),
                             )
                         )
@@ -1072,7 +1098,7 @@ class ManyToManyField(RelatedField):
                         fix = ""
 
                     try:
-                        field = through._meta.get_field(field_name)
+                        field = through._model_meta.get_field(field_name)
                     except FieldDoesNotExist:
                         errors.append(
                             PreflightResult(
@@ -1089,7 +1115,7 @@ class ManyToManyField(RelatedField):
                         ):
                             errors.append(
                                 PreflightResult(
-                                    fix=f"'{through._meta.object_name}.{field_name}' is not a foreign key to '{related_model._meta.object_name}'. {fix}",
+                                    fix=f"'{through.model_options.object_name}.{field_name}' is not a foreign key to '{related_model.model_options.object_name}'. {fix}",
                                     obj=self,
                                     id="fields.m2m_through_field_not_fk_to_model",
                                 )
@@ -1097,19 +1123,19 @@ class ManyToManyField(RelatedField):
 
         return errors
 
-    def _check_table_uniqueness(self, **kwargs):
-        if isinstance(self.remote_field.through, str):
+    def _check_table_uniqueness(self, **kwargs: Any) -> list[PreflightResult]:
+        if isinstance(self.remote_field.through, str):  # type: ignore[attr-defined]
             return []
         registered_tables = {
-            model._meta.db_table: model
-            for model in self.opts.models_registry.get_models()
-            if model != self.remote_field.through
+            model.model_options.db_table: model
+            for model in self.meta.models_registry.get_models()  # type: ignore[attr-defined]
+            if model != self.remote_field.through  # type: ignore[attr-defined]
         }
-        m2m_db_table = self.m2m_db_table()
+        m2m_db_table = self.m2m_db_table()  # type: ignore[attr-defined]
         model = registered_tables.get(m2m_db_table)
         # Check if there's already a m2m field using the same through model.
-        if model and model != self.remote_field.through:
-            clashing_obj = model._meta.label
+        if model and model != self.remote_field.through:  # type: ignore[attr-defined]
+            clashing_obj = model.model_options.label
             return [
                 PreflightResult(
                     fix=(
@@ -1123,71 +1149,73 @@ class ManyToManyField(RelatedField):
             ]
         return []
 
-    def deconstruct(self):
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         name, path, args, kwargs = super().deconstruct()
 
-        if self.remote_field.db_constraint is not True:
-            kwargs["db_constraint"] = self.remote_field.db_constraint
+        if self.remote_field.db_constraint is not True:  # type: ignore[attr-defined]
+            kwargs["db_constraint"] = self.remote_field.db_constraint  # type: ignore[attr-defined]
 
         # Lowercase model names as they should be treated as case-insensitive.
-        if isinstance(self.remote_field.model, str):
-            if "." in self.remote_field.model:
-                package_label, model_name = self.remote_field.model.split(".")
+        if isinstance(self.remote_field.model, str):  # type: ignore[attr-defined]
+            if "." in self.remote_field.model:  # type: ignore[attr-defined]
+                package_label, model_name = self.remote_field.model.split(".")  # type: ignore[attr-defined]
                 kwargs["to"] = f"{package_label}.{model_name.lower()}"
             else:
-                kwargs["to"] = self.remote_field.model.lower()
+                kwargs["to"] = self.remote_field.model.lower()  # type: ignore[attr-defined]
         else:
-            kwargs["to"] = self.remote_field.model._meta.label_lower
+            kwargs["to"] = self.remote_field.model.model_options.label_lower
 
-        if isinstance(self.remote_field.through, str):
-            kwargs["through"] = self.remote_field.through
+        if isinstance(self.remote_field.through, str):  # type: ignore[attr-defined]
+            kwargs["through"] = self.remote_field.through  # type: ignore[attr-defined]
         else:
-            kwargs["through"] = self.remote_field.through._meta.label
+            kwargs["through"] = self.remote_field.through.model_options.label
 
         return name, path, args, kwargs
 
-    def _get_path_info(self, direct=False, filtered_relation=None):
+    def _get_path_info(
+        self, direct: bool = False, filtered_relation: Any = None
+    ) -> list[PathInfo]:
         """Called by both direct and indirect m2m traversal."""
-        int_model = self.remote_field.through
-        linkfield1 = int_model._meta.get_field(self.m2m_field_name())
-        linkfield2 = int_model._meta.get_field(self.m2m_reverse_field_name())
+        int_model = self.remote_field.through  # type: ignore[attr-defined]
+        linkfield1 = int_model._model_meta.get_field(self.m2m_field_name())
+        linkfield2 = int_model._model_meta.get_field(self.m2m_reverse_field_name())
         if direct:
-            join1infos = linkfield1.reverse_path_infos
+            join1infos = linkfield1.reverse_path_infos  # type: ignore[attr-defined]
             if filtered_relation:
-                join2infos = linkfield2.get_path_info(filtered_relation)
+                join2infos = linkfield2.get_path_info(filtered_relation)  # type: ignore[attr-defined]
             else:
-                join2infos = linkfield2.path_infos
+                join2infos = linkfield2.path_infos  # type: ignore[attr-defined]
         else:
-            join1infos = linkfield2.reverse_path_infos
+            join1infos = linkfield2.reverse_path_infos  # type: ignore[attr-defined]
             if filtered_relation:
-                join2infos = linkfield1.get_path_info(filtered_relation)
+                join2infos = linkfield1.get_path_info(filtered_relation)  # type: ignore[attr-defined]
             else:
-                join2infos = linkfield1.path_infos
+                join2infos = linkfield1.path_infos  # type: ignore[attr-defined]
 
         return [*join1infos, *join2infos]
 
-    def get_path_info(self, filtered_relation=None):
+    def get_path_info(self, filtered_relation: Any = None) -> list[PathInfo]:
         return self._get_path_info(direct=True, filtered_relation=filtered_relation)
 
     @cached_property
-    def path_infos(self):
+    def path_infos(self) -> list[PathInfo]:
         return self.get_path_info()
 
-    def get_reverse_path_info(self, filtered_relation=None):
+    def get_reverse_path_info(self, filtered_relation: Any = None) -> list[PathInfo]:
         return self._get_path_info(direct=False, filtered_relation=filtered_relation)
 
     @cached_property
-    def reverse_path_infos(self):
+    def reverse_path_infos(self) -> list[PathInfo]:
         return self.get_reverse_path_info()
 
-    def _get_m2m_db_table(self):
+    def _get_m2m_db_table(self) -> str:
         """
         Function that can be curried to provide the m2m table name for this
         relation.
         """
-        return self.remote_field.through._meta.db_table
+        return self.remote_field.through.model_options.db_table
 
-    def _get_m2m_attr(self, related, attr):
+    def _get_m2m_attr(self, related: Any, attr: str) -> Any:
         """
         Function that can be curried to provide the source accessor or DB
         column name for the m2m table.
@@ -1195,20 +1223,21 @@ class ManyToManyField(RelatedField):
         cache_attr = f"_m2m_{attr}_cache"
         if hasattr(self, cache_attr):
             return getattr(self, cache_attr)
-        if self.remote_field.through_fields is not None:
-            link_field_name = self.remote_field.through_fields[0]
+        if self.remote_field.through_fields is not None:  # type: ignore[attr-defined]
+            link_field_name: str | None = self.remote_field.through_fields[0]  # type: ignore[attr-defined]
         else:
             link_field_name = None
-        for f in self.remote_field.through._meta.fields:
+        for f in self.remote_field.through._model_meta.fields:
             if (
-                f.is_relation
-                and f.remote_field.model == related.related_model
+                f.is_relation  # type: ignore[attr-defined]
+                and f.remote_field.model == related.related_model  # type: ignore[attr-defined]
                 and (link_field_name is None or link_field_name == f.name)
             ):
                 setattr(self, cache_attr, getattr(f, attr))
                 return getattr(self, cache_attr)
+        return None
 
-    def _get_m2m_reverse_attr(self, related, attr):
+    def _get_m2m_reverse_attr(self, related: Any, attr: str) -> Any:
         """
         Function that can be curried to provide the related accessor or DB
         column name for the m2m table.
@@ -1217,12 +1246,12 @@ class ManyToManyField(RelatedField):
         if hasattr(self, cache_attr):
             return getattr(self, cache_attr)
         found = False
-        if self.remote_field.through_fields is not None:
-            link_field_name = self.remote_field.through_fields[1]
+        if self.remote_field.through_fields is not None:  # type: ignore[attr-defined]
+            link_field_name: str | None = self.remote_field.through_fields[1]  # type: ignore[attr-defined]
         else:
             link_field_name = None
-        for f in self.remote_field.through._meta.fields:
-            if f.is_relation and f.remote_field.model == related.model:
+        for f in self.remote_field.through._model_meta.fields:
+            if f.is_relation and f.remote_field.model == related.model:  # type: ignore[attr-defined]
                 if link_field_name is None and related.related_model == related.model:
                     # If this is an m2m-intermediate to self,
                     # the first foreign key you find will be
@@ -1238,64 +1267,69 @@ class ManyToManyField(RelatedField):
                     break
         return getattr(self, cache_attr)
 
-    def contribute_to_class(self, cls, name):
+    def contribute_to_class(self, cls: type[Model], name: str) -> None:
         super().contribute_to_class(cls, name)
 
-        def resolve_through_model(_, model, field):
-            field.remote_field.through = model
+        def resolve_through_model(
+            _: Any, model: type[Model], field: ManyToManyField
+        ) -> None:
+            field.remote_field.through = model  # type: ignore[attr-defined]
 
         lazy_related_operation(
-            resolve_through_model, cls, self.remote_field.through, field=self
+            resolve_through_model,
+            cls,
+            self.remote_field.through,
+            field=self,  # type: ignore[attr-defined]
         )
 
         # Add the descriptor for the m2m relation.
-        setattr(cls, self.name, ForwardManyToManyDescriptor(self.remote_field))
+        setattr(cls, self.name, ForwardManyToManyDescriptor(self.remote_field))  # type: ignore[attr-defined]
 
         # Set up the accessor for the m2m table name for the relation.
-        self.m2m_db_table = self._get_m2m_db_table
+        self.m2m_db_table = self._get_m2m_db_table  # type: ignore[method-assign]
 
-    def contribute_to_related_class(self, cls, related):
+    def contribute_to_related_class(self, cls: type[Model], related: Any) -> None:
         # Internal M2Ms (i.e., those with a related name ending with '+')
         # don't get a related descriptor.
-        if not self.remote_field.is_hidden():
+        if not self.remote_field.is_hidden():  # type: ignore[attr-defined]
             setattr(
                 cls,
                 related.get_accessor_name(),
-                ReverseManyToManyDescriptor(self.remote_field),
+                ReverseManyToManyDescriptor(self.remote_field),  # type: ignore[attr-defined]
             )
 
         # Set up the accessors for the column names on the m2m table.
-        self.m2m_column_name = partial(self._get_m2m_attr, related, "column")
-        self.m2m_reverse_name = partial(self._get_m2m_reverse_attr, related, "column")
+        self.m2m_column_name = partial(self._get_m2m_attr, related, "column")  # type: ignore[method-assign]
+        self.m2m_reverse_name = partial(self._get_m2m_reverse_attr, related, "column")  # type: ignore[method-assign]
 
-        self.m2m_field_name = partial(self._get_m2m_attr, related, "name")
-        self.m2m_reverse_field_name = partial(
+        self.m2m_field_name = partial(self._get_m2m_attr, related, "name")  # type: ignore[method-assign]
+        self.m2m_reverse_field_name = partial(  # type: ignore[method-assign]
             self._get_m2m_reverse_attr, related, "name"
         )
 
         get_m2m_rel = partial(self._get_m2m_attr, related, "remote_field")
-        self.m2m_target_field_name = lambda: get_m2m_rel().field_name
+        self.m2m_target_field_name = lambda: get_m2m_rel().field_name  # type: ignore[method-assign,attr-defined]
         get_m2m_reverse_rel = partial(
             self._get_m2m_reverse_attr, related, "remote_field"
         )
-        self.m2m_reverse_target_field_name = lambda: get_m2m_reverse_rel().field_name
+        self.m2m_reverse_target_field_name = lambda: get_m2m_reverse_rel().field_name  # type: ignore[method-assign,attr-defined]
 
-    def set_attributes_from_rel(self):
+    def set_attributes_from_rel(self) -> None:
         pass
 
-    def value_from_object(self, obj):
-        return [] if obj.id is None else list(getattr(obj, self.attname).all())
+    def value_from_object(self, obj: Model) -> list[Any]:
+        return [] if obj.id is None else list(getattr(obj, self.attname).all())  # type: ignore[attr-defined]
 
-    def save_form_data(self, instance, data):
-        getattr(instance, self.attname).set(data)
+    def save_form_data(self, instance: Model, data: Any) -> None:
+        getattr(instance, self.attname).set(data)  # type: ignore[attr-defined]
 
-    def db_check(self, connection):
+    def db_check(self, connection: BaseDatabaseWrapper) -> None:
         return None
 
-    def db_type(self, connection):
+    def db_type(self, connection: BaseDatabaseWrapper) -> None:
         # A ManyToManyField is not represented by a single column,
         # so return None.
         return None
 
-    def db_parameters(self, connection):
+    def db_parameters(self, connection: BaseDatabaseWrapper) -> dict[str, None]:
         return {"type": None, "check": None}