plain.models 0.50.0__py3-none-any.whl → 0.51.1__py3-none-any.whl

plain/models/fields/related.py

@@ -62,7 +62,7 @@ def resolve_relation(
     # Look for an "app.Model" relation
     if isinstance(relation, str):
         if "." not in relation:
-            relation = f"{scope_model._meta.package_label}.{relation}"  # type: ignore[attr-defined]
+            relation = f"{scope_model.model_options.package_label}.{relation}"
 
     return relation
 
@@ -82,11 +82,11 @@ def lazy_related_operation(
     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  # type: ignore[attr-defined]
+    models_registry = model._model_meta.models_registry
     return models_registry.lazy_model_operation(
         partial(function, **kwargs), *model_keys
     )
@@ -140,7 +140,7 @@ 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.",  # type: ignore[attr-defined]
+                    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",
                 )
@@ -180,13 +180,13 @@ class RelatedField(FieldCacheMixin, Field):
 
     def _check_relation_model_exists(self) -> list[PreflightResult]:
         rel_is_missing = (
-            self.remote_field.model not in self.opts.models_registry.get_models()  # type: ignore[attr-defined]
+            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)  # type: ignore[attr-defined]
         model_name = (
             self.remote_field.model  # type: ignore[attr-defined]
             if rel_is_string
-            else self.remote_field.model._meta.object_name  # type: ignore[attr-defined]
+            else self.remote_field.model.model_options.object_name
         )
         if rel_is_missing and rel_is_string:
             return [
@@ -206,7 +206,6 @@ class RelatedField(FieldCacheMixin, Field):
         from plain.models.base import ModelBase
 
         errors: list[PreflightResult] = []
-        opts = self.model._meta  # type: ignore[attr-defined]
 
         # f.remote_field.model may be a string instead of a model. Skip if
         # model name is not resolved.
@@ -224,8 +223,9 @@ class RelatedField(FieldCacheMixin, Field):
         #         foreign = models.ForeignKey(Target)
         #         m2m = models.ManyToManyField(Target)
 
-        # rel_opts.object_name == "Target"
-        rel_opts = self.remote_field.model._meta  # type: ignore[attr-defined]
+        # 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.
@@ -235,20 +235,20 @@ class RelatedField(FieldCacheMixin, Field):
         )  # 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 "
@@ -275,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 "
@@ -320,21 +318,21 @@ class RelatedField(FieldCacheMixin, Field):
     def contribute_to_class(self, cls: type[Model], name: str) -> None:
         super().contribute_to_class(cls, name)  # type: ignore[misc]
 
-        self.opts = cls._meta  # type: ignore[attr-defined]
+        self.meta = cls._model_meta
 
         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(),  # type: ignore[union-attr]
-                "package_label": cls._meta.package_label.lower(),  # type: ignore[union-attr]
+                "model_name": cls.model_options.model_name.lower(),
+                "package_label": cls.model_options.package_label.lower(),
             }
             self.remote_field.related_name = related_name  # type: ignore[attr-defined]
 
         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(),  # type: ignore[union-attr]
+                "package_label": cls.model_options.package_label.lower(),
             }
             self.remote_field.related_query_name = related_query_name  # type: ignore[attr-defined]
 
@@ -389,7 +387,9 @@ class RelatedField(FieldCacheMixin, Field):
         )
 
     def set_attributes_from_rel(self) -> None:
-        self.name = self.name or (self.remote_field.model._meta.model_name + "_" + "id")  # type: ignore[attr-defined]
+        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: type[Model], cls: type[Model]) -> None:
@@ -415,7 +415,7 @@ class RelatedField(FieldCacheMixin, Field):
         return (
             self.remote_field.related_query_name  # type: ignore[attr-defined]
             or self.remote_field.related_name  # type: ignore[attr-defined]
-            or self.opts.model_name  # type: ignore[attr-defined]
+            or self.model.model_options.model_name  # type: ignore[attr-defined]
         )
 
     @property
@@ -469,10 +469,10 @@ class ForeignKey(RelatedField):
         db_constraint: bool = True,
         **kwargs: Any,
     ):
-        try:
-            to._meta.model_name  # type: ignore[attr-defined]
-        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}"
@@ -565,12 +565,12 @@ class ForeignKey(RelatedField):
 
     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  # type: ignore[attr-defined]
-        from_opts = self.model._meta  # type: ignore[attr-defined]
+        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,
@@ -585,13 +585,13 @@ class ForeignKey(RelatedField):
 
     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  # type: ignore[attr-defined]
-        from_opts = self.remote_field.model._meta  # type: ignore[attr-defined]
+        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"),),
+                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,
@@ -619,7 +619,7 @@ class ForeignKey(RelatedField):
             # it along for later - this is too early because it's still
             # model load time.
             if self.remote_field.limit_choices_to:  # type: ignore[attr-defined]
-                cls._meta.related_fkey_lookups.append(
+                cls._model_meta.related_fkey_lookups.append(
                     self.remote_field.limit_choices_to  # type: ignore[attr-defined]
                 )
 
@@ -669,7 +669,7 @@ class ForeignKey(RelatedField):
             else:
                 kwargs["to"] = self.remote_field.model.lower()  # type: ignore[attr-defined]
         else:
-            kwargs["to"] = self.remote_field.model._meta.label_lower  # type: ignore[attr-defined]
+            kwargs["to"] = self.remote_field.model.model_options.label_lower
 
         if self.db_index is not True:
             kwargs["db_index"] = self.db_index
@@ -691,7 +691,7 @@ class ForeignKey(RelatedField):
         if value is None:
             return None
 
-        qs = self.remote_field.model._meta.base_queryset.filter(  # type: ignore[attr-defined]
+        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())
@@ -700,7 +700,7 @@ class ForeignKey(RelatedField):
                 self.error_messages["invalid"],  # type: ignore[attr-defined]
                 code="invalid",
                 params={
-                    "model": self.remote_field.model._meta.model_name,  # type: ignore[attr-defined]
+                    "model": self.remote_field.model.model_options.model_name,
                     "id": value,
                     "field": self.remote_field.field_name,  # type: ignore[attr-defined]
                     "value": value,
@@ -713,14 +713,14 @@ class ForeignKey(RelatedField):
                 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")  # type: ignore[attr-defined]
+        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:  # 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 "  # type: ignore[attr-defined]
-                    f"'{self.remote_field.model._meta.label}'."  # type: ignore[attr-defined]
+                    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
 
@@ -823,10 +823,10 @@ class ManyToManyField(RelatedField):
         symmetrical: bool | None = None,
         **kwargs: Any,
     ):
-        try:
-            to._meta  # type: ignore[attr-defined]
-        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}"
@@ -915,14 +915,14 @@ class ManyToManyField(RelatedField):
     def _check_relationship_model(
         self, from_model: type[Model] | None = None, **kwargs: Any
     ) -> list[PreflightResult]:
-        if hasattr(self.remote_field.through, "_meta"):
-            qualified_model_name = f"{self.remote_field.through._meta.package_label}.{self.remote_field.through.__name__}"
+        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(
@@ -944,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:
@@ -977,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:
@@ -1078,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
@@ -1088,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),
                             )
                         )
@@ -1096,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(
@@ -1113,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",
                                 )
@@ -1125,15 +1127,15 @@ class ManyToManyField(RelatedField):
         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()  # type: ignore[attr-defined]
+            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()  # 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:  # type: ignore[attr-defined]
-            clashing_obj = model._meta.label
+            clashing_obj = model.model_options.label
             return [
                 PreflightResult(
                     fix=(
@@ -1161,12 +1163,12 @@ class ManyToManyField(RelatedField):
             else:
                 kwargs["to"] = self.remote_field.model.lower()  # type: ignore[attr-defined]
         else:
-            kwargs["to"] = self.remote_field.model._meta.label_lower  # type: ignore[attr-defined]
+            kwargs["to"] = self.remote_field.model.model_options.label_lower
 
         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  # type: ignore[attr-defined]
+            kwargs["through"] = self.remote_field.through.model_options.label
 
         return name, path, args, kwargs
 
@@ -1175,8 +1177,8 @@ class ManyToManyField(RelatedField):
     ) -> list[PathInfo]:
         """Called by both direct and indirect m2m traversal."""
         int_model = self.remote_field.through  # type: ignore[attr-defined]
-        linkfield1 = int_model._meta.get_field(self.m2m_field_name())  # type: ignore[attr-defined]
-        linkfield2 = int_model._meta.get_field(self.m2m_reverse_field_name())  # 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  # type: ignore[attr-defined]
             if filtered_relation:
@@ -1211,7 +1213,7 @@ class ManyToManyField(RelatedField):
         Function that can be curried to provide the m2m table name for this
         relation.
         """
-        return self.remote_field.through._meta.db_table  # type: ignore[attr-defined]
+        return self.remote_field.through.model_options.db_table
 
     def _get_m2m_attr(self, related: Any, attr: str) -> Any:
         """
@@ -1225,7 +1227,7 @@ class ManyToManyField(RelatedField):
             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:  # type: ignore[attr-defined]
+        for f in self.remote_field.through._model_meta.fields:
             if (
                 f.is_relation  # type: ignore[attr-defined]
                 and f.remote_field.model == related.related_model  # type: ignore[attr-defined]
@@ -1248,7 +1250,7 @@ class ManyToManyField(RelatedField):
             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:  # type: ignore[attr-defined]
+        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,

plain/models/fields/related_descriptors.py

@@ -104,7 +104,7 @@ class ForwardManyToOneDescriptor:
         return self.field.is_cached(instance)
 
     def get_queryset(self) -> QuerySet:
-        qs = self.field.remote_field.model._meta.base_queryset
+        qs = self.field.remote_field.model._model_meta.base_queryset
         return qs.all()
 
     def get_prefetch_queryset(
@@ -217,7 +217,7 @@ class ForwardManyToOneDescriptor:
         # An object must be an instance of the related class.
         if value is not None and not isinstance(value, self.field.remote_field.model):
             raise ValueError(
-                f'Cannot assign "{value!r}": "{instance._meta.object_name}.{self.field.name}" must be a "{self.field.remote_field.model._meta.object_name}" instance.'
+                f'Cannot assign "{value!r}": "{instance.model_options.object_name}.{self.field.name}" must be a "{self.field.remote_field.model.model_options.object_name}" instance.'
             )
         remote_field = self.field.remote_field
         # If we're setting the value of a OneToOneField to None, we need to clear

plain/models/fields/related_lookups.py

@@ -55,7 +55,7 @@ def get_normalized_value(value: Any, lhs: Any) -> tuple[Any, ...]:
         sources = lhs.output_field.path_infos[-1].target_fields
         for source in sources:
             while not isinstance(value, source.model) and source.remote_field:
-                source = source.remote_field.model._meta.get_field(
+                source = source.remote_field.model._model_meta.get_field(
                     source.remote_field.field_name
                 )
             try:

plain/models/fields/related_managers.py

@@ -70,8 +70,6 @@ class ReverseManyToOneManager(BaseRelatedManager):
         self.instance = instance
         self.field = rel.field
         self.core_filters = {self.field.name: instance}
-        # Store the base queryset class for this model
-        self.base_queryset_class = rel.related_model._meta.queryset.__class__
         self.allow_null = rel.field.allow_null
 
     def _check_fk_val(self) -> None:
@@ -137,15 +135,14 @@ class ReverseManyToOneManager(BaseRelatedManager):
                 self.field.remote_field.get_cache_name()
             ]
         except (AttributeError, KeyError):
-            # Use the base queryset class for this model
-            queryset = self.base_queryset_class(model=self.model)
+            queryset = self.model.query
             return self._apply_rel_filters(queryset)
 
     def get_prefetch_queryset(
         self, instances: Any, queryset: QuerySet | None = None
     ) -> tuple[QuerySet, Any, Any, bool, str, bool]:
         if queryset is None:
-            queryset = self.base_queryset_class(model=self.model)
+            queryset = self.model.query
 
         rel_obj_attr = self.field.get_local_related_value
         instance_attr = self.field.get_foreign_related_value
@@ -168,7 +165,7 @@ class ReverseManyToOneManager(BaseRelatedManager):
         def check_and_update_obj(obj: Any) -> None:
             if not isinstance(obj, self.model):
                 raise TypeError(
-                    f"'{self.model._meta.object_name}' instance expected, got {obj!r}"
+                    f"'{self.model.model_options.object_name}' instance expected, got {obj!r}"
                 )
             setattr(obj, self.field.name, self.instance)
 
@@ -182,7 +179,7 @@ class ReverseManyToOneManager(BaseRelatedManager):
                         "the object first."
                     )
                 ids.append(obj.id)
-            self.model._meta.base_queryset.filter(id__in=ids).update(
+            self.model._model_meta.base_queryset.filter(id__in=ids).update(
                 **{
                     self.field.name: self.instance,
                 }
@@ -196,17 +193,17 @@ class ReverseManyToOneManager(BaseRelatedManager):
     def create(self, **kwargs: Any) -> Any:
         self._check_fk_val()
         kwargs[self.field.name] = self.instance
-        return self.base_queryset_class(model=self.model).create(**kwargs)
+        return self.model.query.create(**kwargs)
 
     def get_or_create(self, **kwargs: Any) -> tuple[Any, bool]:
         self._check_fk_val()
         kwargs[self.field.name] = self.instance
-        return self.base_queryset_class(model=self.model).get_or_create(**kwargs)
+        return self.model.query.get_or_create(**kwargs)
 
     def update_or_create(self, **kwargs: Any) -> tuple[Any, bool]:
         self._check_fk_val()
         kwargs[self.field.name] = self.instance
-        return self.base_queryset_class(model=self.model).update_or_create(**kwargs)
+        return self.model.query.update_or_create(**kwargs)
 
     def remove(self, *objs: Any, bulk: bool = True) -> None:
         # remove() is only provided if the ForeignKey can have a value of null
@@ -223,7 +220,7 @@ class ReverseManyToOneManager(BaseRelatedManager):
         for obj in objs:
             if not isinstance(obj, self.model):
                 raise TypeError(
-                    f"'{self.model._meta.object_name}' instance expected, got {obj!r}"
+                    f"'{self.model.model_options.object_name}' instance expected, got {obj!r}"
                 )
             # Is obj actually part of this descriptor set?
             if self.field.get_local_related_value(obj) == val:
@@ -297,11 +294,9 @@ class BaseManyToManyManager(BaseRelatedManager):
     def __init__(self, instance: Any, rel: Any):
         self.instance = instance
         self.through = rel.through
-        # Subclasses must set model before calling super().__init__
-        self.base_queryset_class = self.model._meta.queryset.__class__
 
-        self.source_field = self.through._meta.get_field(self.source_field_name)
-        self.target_field = self.through._meta.get_field(self.target_field_name)
+        self.source_field = self.through._model_meta.get_field(self.source_field_name)
+        self.target_field = self.through._model_meta.get_field(self.target_field_name)
 
         self.core_filters = {}
         self.id_field_names = {}
@@ -338,14 +333,14 @@ class BaseManyToManyManager(BaseRelatedManager):
         try:
             return self.instance._prefetched_objects_cache[self.prefetch_cache_name]
         except (AttributeError, KeyError):
-            queryset = self.base_queryset_class(model=self.model)
+            queryset = self.model.query
             return self._apply_rel_filters(queryset)
 
     def get_prefetch_queryset(
         self, instances: Any, queryset: QuerySet | None = None
     ) -> tuple[QuerySet, Any, Any, bool, str, bool]:
         if queryset is None:
-            queryset = self.base_queryset_class(model=self.model)
+            queryset = self.model.query
 
         queryset = _filter_prefetch_queryset(
             queryset._next_is_sticky(), self.query_field_name, instances
@@ -353,8 +348,8 @@ class BaseManyToManyManager(BaseRelatedManager):
 
         # M2M: need to annotate the query in order to get the primary model
         # that the secondary model was actually related to.
-        fk = self.through._meta.get_field(self.source_field_name)
-        join_table = fk.model._meta.db_table
+        fk = self.through._model_meta.get_field(self.source_field_name)
+        join_table = fk.model.model_options.db_table
         qn = db_connection.ops.quote_name
         queryset = queryset.extra(
             select={
@@ -380,9 +375,7 @@ class BaseManyToManyManager(BaseRelatedManager):
     def clear(self) -> None:
         with transaction.atomic(savepoint=False):
             self._remove_prefetched_objects()
-            filters = self._build_remove_filters(
-                self.base_queryset_class(model=self.model)
-            )
+            filters = self._build_remove_filters(self.model.query)
             self.through.query.filter(filters).delete()
 
     def set(
@@ -425,16 +418,14 @@ class BaseManyToManyManager(BaseRelatedManager):
     def create(
         self, *, through_defaults: dict[str, Any] | None = None, **kwargs: Any
     ) -> Any:
-        new_obj = self.base_queryset_class(model=self.model).create(**kwargs)
+        new_obj = self.model.query.create(**kwargs)
         self.add(new_obj, through_defaults=through_defaults)
         return new_obj
 
     def get_or_create(
         self, *, through_defaults: dict[str, Any] | None = None, **kwargs: Any
     ) -> tuple[Any, bool]:
-        obj, created = self.base_queryset_class(model=self.model).get_or_create(
-            **kwargs
-        )
+        obj, created = self.model.query.get_or_create(**kwargs)
         # We only need to add() if created because if we got an object back
         # from get() then the relationship already exists.
         if created:
@@ -444,9 +435,7 @@ class BaseManyToManyManager(BaseRelatedManager):
     def update_or_create(
         self, *, through_defaults: dict[str, Any] | None = None, **kwargs: Any
     ) -> tuple[Any, bool]:
-        obj, created = self.base_queryset_class(model=self.model).update_or_create(
-            **kwargs
-        )
+        obj, created = self.model.query.update_or_create(**kwargs)
         # We only need to add() if created because if we got an object back
         # from get() then the relationship already exists.
         if created:
@@ -458,7 +447,7 @@ class BaseManyToManyManager(BaseRelatedManager):
         from plain.models import Model
 
         target_ids = set()
-        target_field = self.through._meta.get_field(target_field_name)
+        target_field = self.through._model_meta.get_field(target_field_name)
         for obj in objs:
             if isinstance(obj, self.model):
                 target_id = target_field.get_foreign_related_value(obj)[0]
@@ -469,7 +458,7 @@ class BaseManyToManyManager(BaseRelatedManager):
                 target_ids.add(target_id)
             elif isinstance(obj, Model):
                 raise TypeError(
-                    f"'{self.model._meta.object_name}' instance expected, got {obj!r}"
+                    f"'{self.model.model_options.object_name}' instance expected, got {obj!r}"
                 )
             else:
                 target_ids.add(target_field.get_prep_value(obj))
@@ -534,7 +523,7 @@ class BaseManyToManyManager(BaseRelatedManager):
                 old_ids.add(obj)
 
         with transaction.atomic(savepoint=False):
-            target_model_qs = self.base_queryset_class(model=self.model)
+            target_model_qs = self.model.query
             if target_model_qs._has_filters():
                 old_vals = target_model_qs.filter(
                     **{f"{self.target_field.target_field.attname}__in": old_ids}