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

plain/models/base.py

@@ -1,7 +1,14 @@
+from __future__ import annotations
+
 import copy
-import inspect
 import warnings
+from collections.abc import Iterable, Iterator, Sequence
 from itertools import chain
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from plain.models.meta import Meta
+    from plain.models.options import Options
 
 import plain.runtime
 from plain.exceptions import NON_FIELD_ERRORS, ValidationError
@@ -22,19 +29,19 @@ from plain.models.exceptions import (
 from plain.models.expressions import RawSQL, Value
 from plain.models.fields import NOT_PROVIDED, PrimaryKeyField
 from plain.models.fields.reverse_related import ForeignObjectRel
+from plain.models.meta import Meta
 from plain.models.options import Options
 from plain.models.query import F, Q, QuerySet
-from plain.packages import packages_registry
 from plain.preflight import PreflightResult
 from plain.utils.encoding import force_str
 from plain.utils.hashable import make_hashable
 
 
 class Deferred:
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "<Deferred field>"
 
-    def __str__(self):
+    def __str__(self) -> str:
         return "<Deferred field>"
 
 
@@ -44,7 +51,9 @@ DEFERRED = Deferred()
 class ModelBase(type):
     """Metaclass for all models."""
 
-    def __new__(cls, name, bases, attrs, **kwargs):
+    def __new__(
+        cls, name: str, bases: tuple[type, ...], attrs: dict[str, Any], **kwargs: Any
+    ) -> type:
         # Don't do any of this for the root models.Model class.
         if not bases:
             return super().__new__(cls, name, bases, attrs)
@@ -55,75 +64,14 @@ class ModelBase(type):
                 raise TypeError(
                     f"A model can't extend another model: {name} extends {base}"
                 )
-            # Meta has to be defined on the model itself.
-            if hasattr(base, "Meta"):
-                raise TypeError(
-                    "Meta can only be defined on a model itself, not a parent class: "
-                    f"{name} extends {base}"
-                )
-
-        new_class = super().__new__(cls, name, bases, attrs, **kwargs)
-
-        new_class._setup_meta()
-
-        # Now go back over all the attrs on this class see if they have a contribute_to_class() method.
-        # Attributes with contribute_to_class are fields and meta options.
-        for attr_name, attr_value in inspect.getmembers(new_class):
-            if attr_name.startswith("_"):
-                continue
-
-            if not inspect.isclass(attr_value) and hasattr(
-                attr_value, "contribute_to_class"
-            ):
-                if attr_name not in attrs:
-                    # If the field came from an inherited class/mixin,
-                    # we need to make a copy of it to avoid altering the
-                    # original class and other classes that inherit from it.
-                    field = copy.deepcopy(attr_value)
-                else:
-                    field = attr_value
-                field.contribute_to_class(new_class, attr_name)
-
-        # Set the name of _meta.indexes. This can't be done in
-        # Options.contribute_to_class() because fields haven't been added to
-        # the model at that point.
-        for index in new_class._meta.indexes:
-            if not index.name:
-                index.set_name_with_model(new_class)
-
-        return new_class
-
-    def _setup_meta(cls):
-        name = cls.__name__
-        module = cls.__module__
-
-        # The model's Meta class, if it has one.
-        meta = getattr(cls, "Meta", None)
-
-        # Look for an application configuration to attach the model to.
-        package_config = packages_registry.get_containing_package_config(module)
-
-        package_label = getattr(meta, "package_label", None)
-        if package_label is None:
-            if package_config is None:
-                raise RuntimeError(
-                    f"Model class {module}.{name} doesn't declare an explicit "
-                    "package_label and isn't in an application in "
-                    "INSTALLED_PACKAGES."
-                )
-            else:
-                package_label = package_config.package_label
-
-        Options(meta, package_label).contribute_to_class(cls, "_meta")
 
-    @property
-    def query(cls) -> QuerySet:
-        """Create a new QuerySet for this model."""
-        return cls._meta.queryset
+        return super().__new__(cls, name, bases, attrs, **kwargs)
 
 
 class ModelStateFieldsCacheDescriptor:
-    def __get__(self, instance, cls=None):
+    def __get__(
+        self, instance: ModelState | None, cls: type | None = None
+    ) -> ModelStateFieldsCacheDescriptor | dict[str, Any]:
         if instance is None:
             return self
         res = instance.fields_cache = {}
@@ -142,19 +90,20 @@ class ModelState:
 
 
 class Model(metaclass=ModelBase):
-    _meta: Options
+    # Every model gets an automatic id field
+    id = PrimaryKeyField()
 
-    # Use descriptors for exception classes instead of metaclass generation
+    # Descriptors for other model behavior
+    query = QuerySet()
+    model_options = Options()
+    _model_meta = Meta()
     DoesNotExist = DoesNotExistDescriptor()
     MultipleObjectsReturned = MultipleObjectsReturnedDescriptor()
 
-    # Every model gets an automatic id field
-    id = PrimaryKeyField()
-
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any):
         # Alias some things as locals to avoid repeat global lookups
         cls = self.__class__
-        opts = self._meta
+        meta = cls._model_meta
         _setattr = setattr
         _DEFERRED = DEFERRED
 
@@ -165,12 +114,12 @@ class Model(metaclass=ModelBase):
         # overrides it. It should be one or the other; don't duplicate the work
         # The reason for the kwargs check is that standard iterator passes in by
         # args, and instantiation for iteration is 33% faster.
-        if len(args) > len(opts.concrete_fields):
+        if len(args) > len(meta.concrete_fields):
             # Daft, but matches old exception sans the err msg.
             raise IndexError("Number of args exceeds number of fields")
 
         if not kwargs:
-            fields_iter = iter(opts.concrete_fields)
+            fields_iter = iter(meta.concrete_fields)
             # The ordering of the zip calls matter - zip throws StopIteration
             # when an iter throws it. So if the first iter throws it, the second
             # is *not* consumed. We rely on this, so don't change the order
@@ -181,7 +130,7 @@ class Model(metaclass=ModelBase):
                 _setattr(self, field.attname, val)
         else:
             # Slower, kwargs-ready version.
-            fields_iter = iter(opts.fields)
+            fields_iter = iter(meta.fields)
             for val, field in zip(args, fields_iter):
                 if val is _DEFERRED:
                     continue
@@ -236,7 +185,7 @@ class Model(metaclass=ModelBase):
                     _setattr(self, field.attname, val)
 
         if kwargs:
-            property_names = opts._property_names
+            property_names = meta._property_names
             unexpected = ()
             for prop, value in kwargs.items():
                 # Any remaining kwargs must correspond to properties or virtual
@@ -246,7 +195,7 @@ class Model(metaclass=ModelBase):
                         _setattr(self, prop, value)
                 else:
                     try:
-                        opts.get_field(prop)
+                        meta.get_field(prop)
                     except FieldDoesNotExist:
                         unexpected += (prop,)
                     else:
@@ -261,24 +210,24 @@ class Model(metaclass=ModelBase):
         super().__init__()
 
     @classmethod
-    def from_db(cls, field_names, values):
-        if len(values) != len(cls._meta.concrete_fields):
+    def from_db(cls, field_names: Iterable[str], values: Sequence[Any]) -> Model:
+        if len(values) != len(cls._model_meta.concrete_fields):
             values_iter = iter(values)
             values = [
                 next(values_iter) if f.attname in field_names else DEFERRED
-                for f in cls._meta.concrete_fields
+                for f in cls._model_meta.concrete_fields
             ]
         new = cls(*values)
         new._state.adding = False
         return new
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<{self.__class__.__name__}: {self}>"
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"{self.__class__.__name__} object ({self.id})"
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if not isinstance(other, Model):
             return NotImplemented
         if self.__class__ != other.__class__:
@@ -288,18 +237,21 @@ class Model(metaclass=ModelBase):
             return self is other
         return my_id == other.id
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         if self.id is None:
             raise TypeError("Model instances without primary key value are unhashable")
         return hash(self.id)
 
-    def __reduce__(self):
+    def __reduce__(self) -> tuple[Any, tuple[Any, ...], dict[str, Any]]:
         data = self.__getstate__()
         data[PLAIN_VERSION_PICKLE_KEY] = plain.runtime.__version__
-        class_id = self._meta.package_label, self._meta.object_name
+        class_id = (
+            self.model_options.package_label,
+            self.model_options.object_name,
+        )
         return model_unpickle, (class_id,), data
 
-    def __getstate__(self):
+    def __getstate__(self) -> dict[str, Any]:
         """Hook to allow choosing the attributes to pickle."""
         state = self.__dict__.copy()
         state["_state"] = copy.copy(state["_state"])
@@ -316,7 +268,7 @@ class Model(metaclass=ModelBase):
                 state.pop(attr)
         return state
 
-    def __setstate__(self, state):
+    def __setstate__(self, state: dict[str, Any]) -> None:
         pickled_version = state.get(PLAIN_VERSION_PICKLE_KEY)
         if pickled_version:
             if pickled_version != plain.runtime.__version__:
@@ -337,17 +289,17 @@ class Model(metaclass=ModelBase):
                 state[attr] = memoryview(value)
         self.__dict__.update(state)
 
-    def get_deferred_fields(self):
+    def get_deferred_fields(self) -> set[str]:
         """
         Return a set containing names of deferred fields for this instance.
         """
         return {
             f.attname
-            for f in self._meta.concrete_fields
+            for f in self._model_meta.concrete_fields
             if f.attname not in self.__dict__
         }
 
-    def refresh_from_db(self, fields=None):
+    def refresh_from_db(self, fields: list[str] | None = None) -> None:
         """
         Reload field values from the database.
 
@@ -368,7 +320,7 @@ class Model(metaclass=ModelBase):
             prefetched_objects_cache = getattr(self, "_prefetched_objects_cache", ())
             for field in fields:
                 if field in prefetched_objects_cache:
-                    del prefetched_objects_cache[field]
+                    del prefetched_objects_cache[field]  # type: ignore[misc]
                     fields.remove(field)
             if not fields:
                 return
@@ -378,7 +330,7 @@ class Model(metaclass=ModelBase):
                     "are not allowed in fields."
                 )
 
-        db_instance_qs = self.__class__._meta.base_queryset.filter(id=self.id)
+        db_instance_qs = self._model_meta.base_queryset.filter(id=self.id)
 
         # Use provided fields, if not set then reload all non-deferred fields.
         deferred_fields = self.get_deferred_fields()
@@ -388,14 +340,14 @@ class Model(metaclass=ModelBase):
         elif deferred_fields:
             fields = [
                 f.attname
-                for f in self._meta.concrete_fields
+                for f in self._model_meta.concrete_fields
                 if f.attname not in deferred_fields
             ]
             db_instance_qs = db_instance_qs.only(*fields)
 
         db_instance = db_instance_qs.get()
         non_loaded_fields = db_instance.get_deferred_fields()
-        for field in self._meta.concrete_fields:
+        for field in self._model_meta.concrete_fields:
             if field.attname in non_loaded_fields:
                 # This field wasn't refreshed - skip ahead.
                 continue
@@ -405,11 +357,11 @@ class Model(metaclass=ModelBase):
                 field.delete_cached_value(self)
 
         # Clear cached relations.
-        for field in self._meta.related_objects:
+        for field in self._model_meta.related_objects:
             if field.is_cached(self):
                 field.delete_cached_value(self)
 
-    def serializable_value(self, field_name):
+    def serializable_value(self, field_name: str) -> Any:
         """
         Return the value of the field name for this instance. If the field is
         a foreign key, return the id value instead of the object. If there's
@@ -421,7 +373,7 @@ class Model(metaclass=ModelBase):
         and not use this method.
         """
         try:
-            field = self._meta.get_field(field_name)
+            field = self._model_meta.get_field(field_name)
         except FieldDoesNotExist:
             return getattr(self, field_name)
         return getattr(self, field.attname)
@@ -429,11 +381,11 @@ class Model(metaclass=ModelBase):
     def save(
         self,
         *,
-        clean_and_validate=True,
-        force_insert=False,
-        force_update=False,
-        update_fields=None,
-    ):
+        clean_and_validate: bool = True,
+        force_insert: bool = False,
+        force_update: bool = False,
+        update_fields: Iterable[str] | None = None,
+    ) -> None:
         """
         Save the current instance. Override this in a subclass if you want to
         control the saving process.
@@ -456,7 +408,7 @@ class Model(metaclass=ModelBase):
                 return
 
             update_fields = frozenset(update_fields)
-            field_names = self._meta._non_pk_concrete_field_names
+            field_names = self._model_meta._non_pk_concrete_field_names
             non_model_fields = update_fields.difference(field_names)
 
             if non_model_fields:
@@ -471,7 +423,7 @@ class Model(metaclass=ModelBase):
         # on the loaded fields.
         elif not force_insert and deferred_fields:
             field_names = set()
-            for field in self._meta.concrete_fields:
+            for field in self._model_meta.concrete_fields:
                 if not field.primary_key and not hasattr(field, "through"):
                     field_names.add(field.attname)
             loaded_fields = field_names.difference(deferred_fields)
@@ -490,11 +442,11 @@ class Model(metaclass=ModelBase):
     def save_base(
         self,
         *,
-        raw=False,
-        force_insert=False,
-        force_update=False,
-        update_fields=None,
-    ):
+        raw: bool = False,
+        force_insert: bool = False,
+        force_update: bool = False,
+        update_fields: Iterable[str] | None = None,
+    ) -> None:
         """
         Handle the parts of saving which should be done only once per save,
         yet need to be done in raw saves, too. This includes some sanity
@@ -510,28 +462,29 @@ class Model(metaclass=ModelBase):
 
         with transaction.mark_for_rollback_on_error():
             self._save_table(
-                raw,
-                cls,
-                force_insert,
-                force_update,
-                update_fields,
+                raw=raw,
+                cls=cls,
+                force_insert=force_insert,
+                force_update=force_update,
+                update_fields=update_fields,
             )
         # Once saved, this is no longer a to-be-added instance.
         self._state.adding = False
 
     def _save_table(
         self,
-        raw=False,
-        cls=None,
-        force_insert=False,
-        force_update=False,
-        update_fields=None,
-    ):
+        *,
+        raw: bool,
+        cls: type[Model],
+        force_insert: bool = False,
+        force_update: bool = False,
+        update_fields: Iterable[str] | None = None,
+    ) -> bool:
         """
         Do the heavy-lifting involved in saving. Update or insert the data
         for a single table.
         """
-        meta = cls._meta
+        meta = cls._model_meta
         non_pks = [f for f in meta.local_concrete_fields if not f.primary_key]
 
         if update_fields:
@@ -591,7 +544,14 @@ class Model(metaclass=ModelBase):
                     setattr(self, field.attname, value)
         return updated
 
-    def _do_update(self, base_qs, id_val, values, update_fields, forced_update):
+    def _do_update(
+        self,
+        base_qs: QuerySet,
+        id_val: Any,
+        values: list[tuple[Any, Any, Any]],
+        update_fields: Iterable[str] | None,
+        forced_update: bool,
+    ) -> bool:
         """
         Try to update the model. Return True if the model was updated (if an
         update query was done and a matching row was found in the DB).
@@ -606,22 +566,30 @@ class Model(metaclass=ModelBase):
             return update_fields is not None or filtered.exists()
         return filtered._update(values) > 0
 
-    def _do_insert(self, manager, fields, returning_fields, raw):
+    def _do_insert(
+        self,
+        manager: QuerySet,
+        fields: Sequence[Any],
+        returning_fields: Sequence[Any],
+        raw: bool,
+    ) -> list[Any]:
         """
         Do an INSERT. If returning_fields is defined then this method should
         return the newly created data for the model.
         """
-        return manager._insert(
+        return manager._insert(  # type: ignore[return-value, arg-type]
             [self],
-            fields=fields,
-            returning_fields=returning_fields,
+            fields=fields,  # type: ignore[arg-type]
+            returning_fields=returning_fields,  # type: ignore[arg-type]
             raw=raw,
         )
 
-    def _prepare_related_fields_for_save(self, operation_name, fields=None):
+    def _prepare_related_fields_for_save(
+        self, operation_name: str, fields: Sequence[Any] | None = None
+    ) -> None:
         # Ensure that a model instance without a PK hasn't been assigned to
         # a ForeignKey on this model. If the field is nullable, allowing the save would result in silent data loss.
-        for field in self._meta.concrete_fields:
+        for field in self._model_meta.concrete_fields:
             if fields and field not in fields:
                 continue
             # If the related field isn't cached, then an instance hasn't been
@@ -655,10 +623,10 @@ class Model(metaclass=ModelBase):
                 ):
                     field.delete_cached_value(self)
 
-    def delete(self):
+    def delete(self) -> tuple[int, dict[str, int]]:
         if self.id is None:
             raise ValueError(
-                f"{self._meta.object_name} object can't be deleted because its id attribute is set "
+                f"{self.model_options.object_name} object can't be deleted because its id attribute is set "
                 "to None."
             )
         collector = Collector(origin=self)
@@ -668,7 +636,7 @@ class Model(metaclass=ModelBase):
     def get_field_display(self, field_name: str) -> str:
         """Get the display value for a field, especially useful for fields with choices."""
         # Get the field object from the field name
-        field = self._meta.get_field(field_name)
+        field = self._model_meta.get_field(field_name)
         value = getattr(self, field.attname)
 
         # If field has no choices, just return the value as string
@@ -681,24 +649,26 @@ class Model(metaclass=ModelBase):
             choices_dict.get(make_hashable(value), value), strings_only=True
         )
 
-    def _get_field_value_map(self, meta, exclude=None):
+    def _get_field_value_map(
+        self, meta: Meta | None, exclude: set[str] | None = None
+    ) -> dict[str, Value]:
         if exclude is None:
             exclude = set()
-        meta = meta or self._meta
+        meta = meta or self._model_meta
         return {
             field.name: Value(getattr(self, field.attname), field)
             for field in meta.local_concrete_fields
             if field.name not in exclude
         }
 
-    def prepare_database_save(self, field):
+    def prepare_database_save(self, field: Any) -> Any:
         if self.id is None:
             raise ValueError(
                 f"Unsaved model instance {self!r} cannot be used in an ORM query."
             )
         return getattr(self, field.remote_field.get_related_field().attname)
 
-    def clean(self):
+    def clean(self) -> None:
         """
         Hook for doing any extra model-wide validation after clean() has been
         called on every field by self.clean_fields. Any ValidationError raised
@@ -707,7 +677,7 @@ class Model(metaclass=ModelBase):
         """
         pass
 
-    def validate_unique(self, exclude=None):
+    def validate_unique(self, exclude: set[str] | None = None) -> None:
         """
         Check unique constraints on the model and raise ValidationError if any
         failed.
@@ -717,7 +687,9 @@ class Model(metaclass=ModelBase):
         if errors := self._perform_unique_checks(unique_checks):
             raise ValidationError(errors)
 
-    def _get_unique_checks(self, exclude=None):
+    def _get_unique_checks(
+        self, exclude: set[str] | None = None
+    ) -> list[tuple[type, tuple[str, ...]]]:
         """
         Return a list of checks to perform. Since validate_unique() could be
         called from a ModelForm, some fields may have been excluded; we can't
@@ -732,7 +704,7 @@ class Model(metaclass=ModelBase):
         # Gather a list of checks for fields declared as unique and add them to
         # the list of checks.
 
-        fields_with_class = [(self.__class__, self._meta.local_fields)]
+        fields_with_class = [(self.__class__, self._model_meta.local_fields)]
 
         for model_class, fields in fields_with_class:
             for f in fields:
@@ -744,7 +716,9 @@ class Model(metaclass=ModelBase):
 
         return unique_checks
 
-    def _perform_unique_checks(self, unique_checks):
+    def _perform_unique_checks(
+        self, unique_checks: list[tuple[type, tuple[str, ...]]]
+    ) -> dict[str, list[ValidationError]]:
         errors = {}
 
         for model_class, unique_check in unique_checks:
@@ -753,7 +727,7 @@ class Model(metaclass=ModelBase):
 
             lookup_kwargs = {}
             for field_name in unique_check:
-                f = self._meta.get_field(field_name)
+                f = self._model_meta.get_field(field_name)
                 lookup_value = getattr(self, f.attname)
                 # TODO: Handle multiple backends with different feature flags.
                 if lookup_value is None:
@@ -768,7 +742,7 @@ class Model(metaclass=ModelBase):
             if len(unique_check) != len(lookup_kwargs):
                 continue
 
-            qs = model_class.query.filter(**lookup_kwargs)
+            qs = model_class.query.filter(**lookup_kwargs)  # type: ignore[attr-defined]
 
             # Exclude the current object from the query if we are editing an
             # instance (as opposed to creating a new one)
@@ -788,18 +762,20 @@ class Model(metaclass=ModelBase):
 
         return errors
 
-    def unique_error_message(self, model_class, unique_check):
-        opts = model_class._meta
+    def unique_error_message(
+        self, model_class: type[Model], unique_check: tuple[str, ...]
+    ) -> ValidationError:
+        meta = model_class._model_meta
 
         params = {
             "model": self,
             "model_class": model_class,
-            "model_name": opts.model_name,
+            "model_name": model_class.model_options.model_name,
             "unique_check": unique_check,
         }
 
         if len(unique_check) == 1:
-            field = opts.get_field(unique_check[0])
+            field = meta.get_field(unique_check[0])
             params["field_label"] = field.name
             return ValidationError(
                 message=field.error_messages["unique"],
@@ -807,7 +783,7 @@ class Model(metaclass=ModelBase):
                 params=params,
             )
         else:
-            field_names = [opts.get_field(f).name for f in unique_check]
+            field_names = [meta.get_field(f).name for f in unique_check]
 
             # Put an "and" before the last one
             field_names[-1] = f"and {field_names[-1]}"
@@ -820,7 +796,7 @@ class Model(metaclass=ModelBase):
                 params["field_label"] = " ".join(field_names)
 
             # Use the first field as the message format...
-            message = opts.get_field(unique_check[0]).error_messages["unique"]
+            message = meta.get_field(unique_check[0]).error_messages["unique"]
 
             return ValidationError(
                 message=message,
@@ -828,11 +804,11 @@ class Model(metaclass=ModelBase):
                 params=params,
             )
 
-    def get_constraints(self):
-        constraints = [(self.__class__, self._meta.constraints)]
+    def get_constraints(self) -> list[tuple[type, list[Any]]]:
+        constraints = [(self.__class__, self.model_options.constraints)]
         return constraints
 
-    def validate_constraints(self, exclude=None):
+    def validate_constraints(self, exclude: set[str] | None = None) -> None:
         constraints = self.get_constraints()
 
         errors = {}
@@ -852,8 +828,12 @@ class Model(metaclass=ModelBase):
             raise ValidationError(errors)
 
     def full_clean(
-        self, *, exclude=None, validate_unique=True, validate_constraints=True
-    ):
+        self,
+        *,
+        exclude: set[str] | Iterable[str] | None = None,
+        validate_unique: bool = True,
+        validate_constraints: bool = True,
+    ) -> None:
         """
         Call clean_fields(), clean(), validate_unique(), and
         validate_constraints() on the model. Raise a ValidationError for any
@@ -900,7 +880,7 @@ class Model(metaclass=ModelBase):
         if errors:
             raise ValidationError(errors)
 
-    def clean_fields(self, exclude=None):
+    def clean_fields(self, exclude: set[str] | None = None) -> None:
         """
         Clean all fields and raise a ValidationError containing a dict
         of all validation errors if any occur.
@@ -909,7 +889,7 @@ class Model(metaclass=ModelBase):
             exclude = set()
 
         errors = {}
-        for f in self._meta.fields:
+        for f in self._model_meta.fields:
             if f.name in exclude:
                 continue
             # Skip validation for empty fields with required=False. The developer
@@ -926,7 +906,7 @@ class Model(metaclass=ModelBase):
             raise ValidationError(errors)
 
     @classmethod
-    def preflight(cls):
+    def preflight(cls) -> list[PreflightResult]:
         errors = []
 
         errors += [
@@ -956,13 +936,13 @@ class Model(metaclass=ModelBase):
         return errors
 
     @classmethod
-    def _check_db_table_comment(cls):
-        if not cls._meta.db_table_comment:
+    def _check_db_table_comment(cls) -> list[PreflightResult]:
+        if not cls.model_options.db_table_comment:
             return []
         errors = []
         if not (
             db_connection.features.supports_comments
-            or "supports_comments" in cls._meta.required_db_features
+            or "supports_comments" in cls.model_options.required_db_features
         ):
             errors.append(
                 PreflightResult(
@@ -976,23 +956,23 @@ class Model(metaclass=ModelBase):
         return errors
 
     @classmethod
-    def _check_fields(cls):
+    def _check_fields(cls) -> list[PreflightResult]:
         """Perform all field checks."""
         errors = []
-        for field in cls._meta.local_fields:
+        for field in cls._model_meta.local_fields:
             errors.extend(field.preflight(from_model=cls))
-        for field in cls._meta.local_many_to_many:
+        for field in cls._model_meta.local_many_to_many:
             errors.extend(field.preflight(from_model=cls))
         return errors
 
     @classmethod
-    def _check_m2m_through_same_relationship(cls):
+    def _check_m2m_through_same_relationship(cls) -> list[PreflightResult]:
         """Check if no relationship model is used by more than one m2m field."""
 
         errors = []
         seen_intermediary_signatures = []
 
-        fields = cls._meta.local_many_to_many
+        fields = cls._model_meta.local_many_to_many
 
         # Skip when the target model wasn't found.
         fields = (f for f in fields if isinstance(f.remote_field.model, ModelBase))
@@ -1011,7 +991,7 @@ class Model(metaclass=ModelBase):
                 errors.append(
                     PreflightResult(
                         fix="The model has two identical many-to-many relations "
-                        f"through the intermediate model '{f.remote_field.through._meta.label}'.",
+                        f"through the intermediate model '{f.remote_field.through.model_options.label}'.",
                         obj=cls,
                         id="models.duplicate_many_to_many_relations",
                     )
@@ -1021,10 +1001,12 @@ class Model(metaclass=ModelBase):
         return errors
 
     @classmethod
-    def _check_id_field(cls):
+    def _check_id_field(cls) -> list[PreflightResult]:
         """Disallow user-defined fields named ``id``."""
         if any(
-            f for f in cls._meta.local_fields if f.name == "id" and not f.auto_created
+            f
+            for f in cls._model_meta.local_fields
+            if f.name == "id" and not f.auto_created
         ):
             return [
                 PreflightResult(
@@ -1036,12 +1018,12 @@ class Model(metaclass=ModelBase):
         return []
 
     @classmethod
-    def _check_field_name_clashes(cls):
+    def _check_field_name_clashes(cls) -> list[PreflightResult]:
         """Forbid field shadowing in multi-table inheritance."""
         errors = []
         used_fields = {}  # name or attname -> field
 
-        for f in cls._meta.local_fields:
+        for f in cls._model_meta.local_fields:
             clash = used_fields.get(f.name) or used_fields.get(f.attname) or None
             # Note that we may detect clash between user-defined non-unique
             # field "id" and automatically added unique field "id", both
@@ -1054,7 +1036,7 @@ class Model(metaclass=ModelBase):
                 errors.append(
                     PreflightResult(
                         fix=f"The field '{f.name}' clashes with the field '{clash.name}' "
-                        f"from model '{clash.model._meta}'.",
+                        f"from model '{clash.model.model_options}'.",
                         obj=f,
                         id="models.field_name_clash",
                     )
@@ -1065,12 +1047,12 @@ class Model(metaclass=ModelBase):
         return errors
 
     @classmethod
-    def _check_column_name_clashes(cls):
+    def _check_column_name_clashes(cls) -> list[PreflightResult]:
         # Store a list of column names which have already been used by other fields.
         used_column_names = []
         errors = []
 
-        for f in cls._meta.local_fields:
+        for f in cls._model_meta.local_fields:
             _, column_name = f.get_attname_column()
 
             # Ensure the column name is not already in use.
@@ -1089,7 +1071,7 @@ class Model(metaclass=ModelBase):
         return errors
 
     @classmethod
-    def _check_model_name_db_lookup_clashes(cls):
+    def _check_model_name_db_lookup_clashes(cls) -> list[PreflightResult]:
         errors = []
         model_name = cls.__name__
         if model_name.startswith("_") or model_name.endswith("_"):
@@ -1113,12 +1095,14 @@ class Model(metaclass=ModelBase):
         return errors
 
     @classmethod
-    def _check_property_name_related_field_accessor_clashes(cls):
+    def _check_property_name_related_field_accessor_clashes(
+        cls,
+    ) -> list[PreflightResult]:
         errors = []
-        property_names = cls._meta._property_names
+        property_names = cls._model_meta._property_names
         related_field_accessors = (
             f.get_attname()
-            for f in cls._meta._get_fields(reverse=False)
+            for f in cls._model_meta._get_fields(reverse=False)
             if f.is_relation and f.related_model is not None
         )
         for accessor in related_field_accessors:
@@ -1134,9 +1118,9 @@ class Model(metaclass=ModelBase):
         return errors
 
     @classmethod
-    def _check_single_primary_key(cls):
+    def _check_single_primary_key(cls) -> list[PreflightResult]:
         errors = []
-        if sum(1 for f in cls._meta.local_fields if f.primary_key) > 1:
+        if sum(1 for f in cls._model_meta.local_fields if f.primary_key) > 1:
             errors.append(
                 PreflightResult(
                     fix="The model cannot have more than one field with "
@@ -1148,11 +1132,11 @@ class Model(metaclass=ModelBase):
         return errors
 
     @classmethod
-    def _check_indexes(cls):
+    def _check_indexes(cls) -> list[PreflightResult]:
         """Check fields, names, and conditions of indexes."""
         errors = []
         references = set()
-        for index in cls._meta.indexes:
+        for index in cls.model_options.indexes:
             # Index name can't start with an underscore or a number, restricted
             # for cross-database compatibility with Oracle.
             if index.name[0] == "_" or index.name[0].isdigit():
@@ -1180,8 +1164,8 @@ class Model(metaclass=ModelBase):
                     )
         if not (
             db_connection.features.supports_partial_indexes
-            or "supports_partial_indexes" in cls._meta.required_db_features
-        ) and any(index.condition is not None for index in cls._meta.indexes):
+            or "supports_partial_indexes" in cls.model_options.required_db_features
+        ) and any(index.condition is not None for index in cls.model_options.indexes):
             errors.append(
                 PreflightResult(
                     fix=f"{db_connection.display_name} does not support indexes with conditions. "
@@ -1194,8 +1178,8 @@ class Model(metaclass=ModelBase):
             )
         if not (
             db_connection.features.supports_covering_indexes
-            or "supports_covering_indexes" in cls._meta.required_db_features
-        ) and any(index.include for index in cls._meta.indexes):
+            or "supports_covering_indexes" in cls.model_options.required_db_features
+        ) and any(index.include for index in cls.model_options.indexes):
             errors.append(
                 PreflightResult(
                     fix=f"{db_connection.display_name} does not support indexes with non-key columns. "
@@ -1208,8 +1192,8 @@ class Model(metaclass=ModelBase):
             )
         if not (
             db_connection.features.supports_expression_indexes
-            or "supports_expression_indexes" in cls._meta.required_db_features
-        ) and any(index.contains_expressions for index in cls._meta.indexes):
+            or "supports_expression_indexes" in cls.model_options.required_db_features
+        ) and any(index.contains_expressions for index in cls.model_options.indexes):
             errors.append(
                 PreflightResult(
                     fix=f"{db_connection.display_name} does not support indexes on expressions. "
@@ -1221,21 +1205,27 @@ class Model(metaclass=ModelBase):
                 )
             )
         fields = [
-            field for index in cls._meta.indexes for field, _ in index.fields_orders
+            field
+            for index in cls.model_options.indexes
+            for field, _ in index.fields_orders
+        ]
+        fields += [
+            include for index in cls.model_options.indexes for include in index.include
         ]
-        fields += [include for index in cls._meta.indexes for include in index.include]
         fields += references
         errors.extend(cls._check_local_fields(fields, "indexes"))
         return errors
 
     @classmethod
-    def _check_local_fields(cls, fields, option):
+    def _check_local_fields(
+        cls, fields: Iterable[str], option: str
+    ) -> list[PreflightResult]:
         from plain import models
 
         # In order to avoid hitting the relation tree prematurely, we use our
         # own fields_map instead of using get_field()
         forward_fields_map = {}
-        for field in cls._meta._get_fields(reverse=False):
+        for field in cls._model_meta._get_fields(reverse=False):
             forward_fields_map[field.name] = field
             if hasattr(field, "attname"):
                 forward_fields_map[field.attname] = field
@@ -1262,11 +1252,11 @@ class Model(metaclass=ModelBase):
                             id="models.m2m_field_in_meta_option",
                         )
                     )
-                elif field not in cls._meta.local_fields:
+                elif field not in cls._model_meta.local_fields:
                     errors.append(
                         PreflightResult(
                             fix=f"'{option}' refers to field '{field_name}' which is not local to model "
-                            f"'{cls._meta.object_name}'. This issue may be caused by multi-table inheritance.",
+                            f"'{cls.model_options.object_name}'. This issue may be caused by multi-table inheritance.",
                             obj=cls,
                             id="models.non_local_field_reference",
                         )
@@ -1274,16 +1264,16 @@ class Model(metaclass=ModelBase):
         return errors
 
     @classmethod
-    def _check_ordering(cls):
+    def _check_ordering(cls) -> list[PreflightResult]:
         """
         Check "ordering" option -- is it a list of strings and do all fields
         exist?
         """
 
-        if not cls._meta.ordering:
+        if not cls.model_options.ordering:
             return []
 
-        if not isinstance(cls._meta.ordering, list | tuple):
+        if not isinstance(cls.model_options.ordering, list | tuple):
             return [
                 PreflightResult(
                     fix="'ordering' must be a tuple or list (even if you want to order by "
@@ -1294,7 +1284,7 @@ class Model(metaclass=ModelBase):
             ]
 
         errors = []
-        fields = cls._meta.ordering
+        fields = cls.model_options.ordering
 
         # Skip expressions and '?' fields.
         fields = (f for f in fields if isinstance(f, str) and f != "?")
@@ -1318,9 +1308,9 @@ class Model(metaclass=ModelBase):
             fld = None
             for part in field.split(LOOKUP_SEP):
                 try:
-                    fld = _cls._meta.get_field(part)
+                    fld = _cls._model_meta.get_field(part)
                     if fld.is_relation:
-                        _cls = fld.path_infos[-1].to_opts.model
+                        _cls = fld.path_infos[-1].to_meta.model
                     else:
                         _cls = None
                 except (FieldDoesNotExist, AttributeError):
@@ -1341,13 +1331,13 @@ class Model(metaclass=ModelBase):
 
         # Any field name that is not present in field_names does not exist.
         # Also, ordering by m2m fields is not allowed.
-        opts = cls._meta
+        meta = cls._model_meta
         valid_fields = set(
             chain.from_iterable(
                 (f.name, f.attname)
                 if not (f.auto_created and not f.concrete)
                 else (f.field.related_query_name(),)
-                for f in chain(opts.fields, opts.related_objects)
+                for f in chain(meta.fields, meta.related_objects)
             )
         )
 
@@ -1365,7 +1355,7 @@ class Model(metaclass=ModelBase):
         return errors
 
     @classmethod
-    def _check_long_column_names(cls):
+    def _check_long_column_names(cls) -> list[PreflightResult]:
         """
         Check that any auto-generated column names are shorter than the limits
         for each database in which the model will be created.
@@ -1380,7 +1370,7 @@ class Model(metaclass=ModelBase):
         if allowed_len is None:
             return errors
 
-        for f in cls._meta.local_fields:
+        for f in cls._model_meta.local_fields:
             _, column_name = f.get_attname_column()
 
             # Check if auto-generated name for the field is too long
@@ -1400,14 +1390,14 @@ class Model(metaclass=ModelBase):
                     )
                 )
 
-        for f in cls._meta.local_many_to_many:
+        for f in cls._model_meta.local_many_to_many:
             # Skip nonexistent models.
             if isinstance(f.remote_field.through, str):
                 continue
 
             # Check if auto-generated name for the M2M field is too long
             # for the database.
-            for m2m in f.remote_field.through._meta.local_fields:
+            for m2m in f.remote_field.through._model_meta.local_fields:
                 _, rel_name = m2m.get_attname_column()
                 if (
                     m2m.db_column is None
@@ -1428,7 +1418,7 @@ class Model(metaclass=ModelBase):
         return errors
 
     @classmethod
-    def _get_expr_references(cls, expr):
+    def _get_expr_references(cls, expr: Any) -> Iterator[tuple[str, ...]]:
         if isinstance(expr, Q):
             for child in expr.children:
                 if isinstance(child, tuple):
@@ -1444,14 +1434,15 @@ class Model(metaclass=ModelBase):
                 yield from cls._get_expr_references(src_expr)
 
     @classmethod
-    def _check_constraints(cls):
+    def _check_constraints(cls) -> list[PreflightResult]:
         errors = []
         if not (
             db_connection.features.supports_table_check_constraints
-            or "supports_table_check_constraints" in cls._meta.required_db_features
+            or "supports_table_check_constraints"
+            in cls.model_options.required_db_features
         ) and any(
             isinstance(constraint, CheckConstraint)
-            for constraint in cls._meta.constraints
+            for constraint in cls.model_options.constraints
         ):
             errors.append(
                 PreflightResult(
@@ -1466,11 +1457,11 @@ class Model(metaclass=ModelBase):
 
         if not (
             db_connection.features.supports_partial_indexes
-            or "supports_partial_indexes" in cls._meta.required_db_features
+            or "supports_partial_indexes" in cls.model_options.required_db_features
         ) and any(
             isinstance(constraint, UniqueConstraint)
             and constraint.condition is not None
-            for constraint in cls._meta.constraints
+            for constraint in cls.model_options.constraints
         ):
             errors.append(
                 PreflightResult(
@@ -1486,11 +1477,11 @@ class Model(metaclass=ModelBase):
         if not (
             db_connection.features.supports_deferrable_unique_constraints
             or "supports_deferrable_unique_constraints"
-            in cls._meta.required_db_features
+            in cls.model_options.required_db_features
         ) and any(
             isinstance(constraint, UniqueConstraint)
             and constraint.deferrable is not None
-            for constraint in cls._meta.constraints
+            for constraint in cls.model_options.constraints
         ):
             errors.append(
                 PreflightResult(
@@ -1505,10 +1496,10 @@ class Model(metaclass=ModelBase):
 
         if not (
             db_connection.features.supports_covering_indexes
-            or "supports_covering_indexes" in cls._meta.required_db_features
+            or "supports_covering_indexes" in cls.model_options.required_db_features
         ) and any(
             isinstance(constraint, UniqueConstraint) and constraint.include
-            for constraint in cls._meta.constraints
+            for constraint in cls.model_options.constraints
         ):
             errors.append(
                 PreflightResult(
@@ -1523,10 +1514,10 @@ class Model(metaclass=ModelBase):
 
         if not (
             db_connection.features.supports_expression_indexes
-            or "supports_expression_indexes" in cls._meta.required_db_features
+            or "supports_expression_indexes" in cls.model_options.required_db_features
         ) and any(
             isinstance(constraint, UniqueConstraint) and constraint.contains_expressions
-            for constraint in cls._meta.constraints
+            for constraint in cls.model_options.constraints
         ):
             errors.append(
                 PreflightResult(
@@ -1541,22 +1532,23 @@ class Model(metaclass=ModelBase):
         fields = set(
             chain.from_iterable(
                 (*constraint.fields, *constraint.include)
-                for constraint in cls._meta.constraints
+                for constraint in cls.model_options.constraints
                 if isinstance(constraint, UniqueConstraint)
             )
         )
         references = set()
-        for constraint in cls._meta.constraints:
+        for constraint in cls.model_options.constraints:
             if isinstance(constraint, UniqueConstraint):
                 if (
                     db_connection.features.supports_partial_indexes
-                    or "supports_partial_indexes" not in cls._meta.required_db_features
+                    or "supports_partial_indexes"
+                    not in cls.model_options.required_db_features
                 ) and isinstance(constraint.condition, Q):
                     references.update(cls._get_expr_references(constraint.condition))
                 if (
                     db_connection.features.supports_expression_indexes
                     or "supports_expression_indexes"
-                    not in cls._meta.required_db_features
+                    not in cls.model_options.required_db_features
                 ) and constraint.contains_expressions:
                     for expression in constraint.expressions:
                         references.update(cls._get_expr_references(expression))
@@ -1564,7 +1556,7 @@ class Model(metaclass=ModelBase):
                 if (
                     db_connection.features.supports_table_check_constraints
                     or "supports_table_check_constraints"
-                    not in cls._meta.required_db_features
+                    not in cls.model_options.required_db_features
                 ):
                     if isinstance(constraint.check, Q):
                         references.update(cls._get_expr_references(constraint.check))
@@ -1588,7 +1580,7 @@ class Model(metaclass=ModelBase):
                 # If it has no lookups it cannot result in a JOIN.
                 continue
             try:
-                field = cls._meta.get_field(field_name)
+                field = cls._model_meta.get_field(field_name)
                 if not field.is_relation or field.many_to_many or field.one_to_many:
                     continue
             except FieldDoesNotExist:
@@ -1617,7 +1609,7 @@ class Model(metaclass=ModelBase):
 ########
 
 
-def model_unpickle(model_id):
+def model_unpickle(model_id: tuple[str, str] | type[Model]) -> Model:
     """Used to unpickle Model subclasses with deferred fields."""
     if isinstance(model_id, tuple):
         model = models_registry.get_model(*model_id)
@@ -1627,4 +1619,4 @@ def model_unpickle(model_id):
     return model.__new__(model)
 
 
-model_unpickle.__safe_for_unpickle__ = True
+model_unpickle.__safe_for_unpickle__ = True  # type: ignore[attr-defined]