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

plain/models/fields/related_descriptors.py

@@ -46,7 +46,10 @@ reverse many-to-one relation.
    ``ReverseManyToManyDescriptor``, use ``ManyToManyDescriptor`` instead.
 """
 
+from __future__ import annotations
+
 from functools import cached_property
+from typing import Any
 
 from plain.models.query import QuerySet
 from plain.models.query_utils import DeferredAttribute
@@ -60,7 +63,7 @@ from .related_managers import (
 
 
 class ForeignKeyDeferredAttribute(DeferredAttribute):
-    def __set__(self, instance, value):
+    def __set__(self, instance: Any, value: Any) -> None:
         if instance.__dict__.get(self.field.attname) != value and self.field.is_cached(
             instance
         ):
@@ -80,11 +83,11 @@ class ForwardManyToOneDescriptor:
     ``Child.parent`` is a ``ForwardManyToOneDescriptor`` instance.
     """
 
-    def __init__(self, field_with_rel):
+    def __init__(self, field_with_rel: Any) -> None:
         self.field = field_with_rel
 
     @cached_property
-    def RelatedObjectDoesNotExist(self):
+    def RelatedObjectDoesNotExist(self) -> type:
         # The exception can't be created at initialization time since the
         # related model might not be resolved yet; `self.field.model` might
         # still be a string model reference.
@@ -97,14 +100,16 @@ class ForwardManyToOneDescriptor:
             },
         )
 
-    def is_cached(self, instance):
+    def is_cached(self, instance: Any) -> bool:
         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(self, instances, queryset=None):
+    def get_prefetch_queryset(
+        self, instances: list[Any], queryset: QuerySet | None = None
+    ) -> tuple[QuerySet, Any, Any, bool, str, bool]:
         if queryset is None:
             queryset = self.get_queryset()
 
@@ -145,12 +150,14 @@ class ForwardManyToOneDescriptor:
             False,
         )
 
-    def get_object(self, instance):
+    def get_object(self, instance: Any) -> Any:
         qs = self.get_queryset()
         # Assuming the database enforces foreign keys, this won't fail.
         return qs.get(self.field.get_reverse_related_filter(instance))
 
-    def __get__(self, instance, cls=None):
+    def __get__(
+        self, instance: Any | None, cls: type | None = None
+    ) -> ForwardManyToOneDescriptor | Any | None:
         """
         Get the related instance through the forward relation.
 
@@ -189,7 +196,7 @@ class ForwardManyToOneDescriptor:
         else:
             return rel_obj
 
-    def __set__(self, instance, value):
+    def __set__(self, instance: Any, value: Any) -> None:
         """
         Set the related instance through the forward relation.
 
@@ -210,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
@@ -250,7 +257,7 @@ class ForwardManyToOneDescriptor:
         if value is not None and not remote_field.multiple:
             remote_field.set_cached_value(value, instance)
 
-    def __reduce__(self):
+    def __reduce__(self) -> tuple[Any, tuple[Any, str]]:
         """
         Pickling should return the instance attached by self.field on the
         model, not a new copy of that descriptor. Use getattr() to retrieve
@@ -268,11 +275,13 @@ class RelationDescriptorBase:
     this because they allow direct assignment.
     """
 
-    def __init__(self, rel):
+    def __init__(self, rel: Any) -> None:
         self.rel = rel
         self.field = rel.field
 
-    def __get__(self, instance, cls=None):
+    def __get__(
+        self, instance: Any | None, cls: type | None = None
+    ) -> RelationDescriptorBase | Any:
         """
         Get the related manager when the descriptor is accessed.
 
@@ -282,19 +291,19 @@ class RelationDescriptorBase:
             return self
         return self.get_related_manager(instance)
 
-    def get_related_manager(self, instance):
+    def get_related_manager(self, instance: Any) -> Any:
         """Return the appropriate manager for this relation."""
         raise NotImplementedError(
             f"{self.__class__.__name__} must implement get_related_manager()"
         )
 
-    def _get_set_deprecation_msg_params(self):
+    def _get_set_deprecation_msg_params(self) -> tuple[str, str]:
         """Return parameters for the error message when direct assignment is attempted."""
         raise NotImplementedError(
             f"{self.__class__.__name__} must implement _get_set_deprecation_msg_params()"
         )
 
-    def __set__(self, instance, value):
+    def __set__(self, instance: Any, value: Any) -> None:
         """Prevent direct assignment to the relation."""
         raise TypeError(
             "Direct assignment to the {} is prohibited. Use {}.set() instead.".format(
@@ -318,11 +327,11 @@ class ReverseManyToOneDescriptor(RelationDescriptorBase):
     Most of the implementation is delegated to the ReverseManyToOneManager class.
     """
 
-    def get_related_manager(self, instance):
+    def get_related_manager(self, instance: Any) -> ReverseManyToOneManager:
         """Return the ReverseManyToOneManager for this relation."""
         return ReverseManyToOneManager(instance, self.rel)
 
-    def _get_set_deprecation_msg_params(self):
+    def _get_set_deprecation_msg_params(self) -> tuple[str, str]:
         return (
             "reverse side of a related set",
             self.rel.get_accessor_name(),
@@ -343,17 +352,17 @@ class ForwardManyToManyDescriptor(RelationDescriptorBase):
     """
 
     @property
-    def through(self):
+    def through(self) -> Any:
         # through is provided so that you have easy access to the through
         # model (Book.authors.through) for inlines, etc. This is done as
         # a property to ensure that the fully resolved value is returned.
         return self.rel.through
 
-    def get_related_manager(self, instance):
+    def get_related_manager(self, instance: Any) -> ForwardManyToManyManager:
         """Return the ForwardManyToManyManager for this relation."""
         return ForwardManyToManyManager(instance, self.rel)
 
-    def _get_set_deprecation_msg_params(self):
+    def _get_set_deprecation_msg_params(self) -> tuple[str, str]:
         return (
             "forward side of a many-to-many set",
             self.field.name,
@@ -374,17 +383,17 @@ class ReverseManyToManyDescriptor(RelationDescriptorBase):
     """
 
     @property
-    def through(self):
+    def through(self) -> Any:
         # through is provided so that you have easy access to the through
         # model (Book.authors.through) for inlines, etc. This is done as
         # a property to ensure that the fully resolved value is returned.
         return self.rel.through
 
-    def get_related_manager(self, instance):
+    def get_related_manager(self, instance: Any) -> ReverseManyToManyManager:
         """Return the ReverseManyToManyManager for this relation."""
         return ReverseManyToManyManager(instance, self.rel)
 
-    def _get_set_deprecation_msg_params(self):
+    def _get_set_deprecation_msg_params(self) -> tuple[str, str]:
         return (
             "reverse side of a many-to-many set",
             self.rel.get_accessor_name(),

plain/models/fields/related_lookups.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
 from plain.models.lookups import (
     Exact,
     GreaterThan,
@@ -8,12 +12,16 @@ from plain.models.lookups import (
     LessThanOrEqual,
 )
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+    from plain.models.sql.compiler import SQLCompiler
+
 
 class MultiColSource:
     contains_aggregate = False
     contains_over_clause = False
 
-    def __init__(self, alias, targets, sources, field):
+    def __init__(self, alias: str, targets: Any, sources: Any, field: Any) -> None:
         self.targets, self.sources, self.field, self.alias = (
             targets,
             sources,
@@ -22,22 +30,22 @@ class MultiColSource:
         )
         self.output_field = self.field
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.alias}, {self.field})"
 
-    def relabeled_clone(self, relabels):
+    def relabeled_clone(self, relabels: dict[str, str]) -> MultiColSource:
         return self.__class__(
             relabels.get(self.alias, self.alias), self.targets, self.sources, self.field
         )
 
-    def get_lookup(self, lookup):
+    def get_lookup(self, lookup: str) -> Any:
         return self.output_field.get_lookup(lookup)
 
-    def resolve_expression(self, *args, **kwargs):
+    def resolve_expression(self, *args: Any, **kwargs: Any) -> MultiColSource:
         return self
 
 
-def get_normalized_value(value, lhs):
+def get_normalized_value(value: Any, lhs: Any) -> tuple[Any, ...]:
     from plain.models import Model
 
     if isinstance(value, Model):
@@ -47,7 +55,7 @@ def get_normalized_value(value, lhs):
         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:
@@ -63,7 +71,7 @@ def get_normalized_value(value, lhs):
 
 
 class RelatedIn(In):
-    def get_prep_lookup(self):
+    def get_prep_lookup(self) -> list[Any]:  # type: ignore[misc]
         if not isinstance(self.lhs, MultiColSource):
             if self.rhs_is_direct_value():
                 # If we get here, we are dealing with single-column relations.
@@ -97,7 +105,9 @@ class RelatedIn(In):
                 self.rhs.set_values([target_field])
         return super().get_prep_lookup()
 
-    def as_sql(self, compiler, connection):
+    def as_sql(
+        self, compiler: SQLCompiler, connection: BaseDatabaseWrapper
+    ) -> tuple[str, list[Any]]:  # type: ignore[misc]
         if isinstance(self.lhs, MultiColSource):
             # For multicolumn lookups we need to build a multicolumn where clause.
             # This clause is either a SubqueryConstraint (for values that need
@@ -139,7 +149,7 @@ class RelatedIn(In):
 
 
 class RelatedLookupMixin:
-    def get_prep_lookup(self):
+    def get_prep_lookup(self) -> Any:  # type: ignore[misc]
         if not isinstance(self.lhs, MultiColSource) and not hasattr(
             self.rhs, "resolve_expression"
         ):
@@ -155,9 +165,11 @@ class RelatedLookupMixin:
                 target_field = self.lhs.output_field.path_infos[-1].target_fields[-1]
                 self.rhs = target_field.get_prep_value(self.rhs)
 
-        return super().get_prep_lookup()
+        return super().get_prep_lookup()  # type: ignore[misc]
 
-    def as_sql(self, compiler, connection):
+    def as_sql(
+        self, compiler: SQLCompiler, connection: BaseDatabaseWrapper
+    ) -> tuple[str, list[Any]]:  # type: ignore[misc]
         if isinstance(self.lhs, MultiColSource):
             assert self.rhs_is_direct_value()
             self.rhs = get_normalized_value(self.rhs, self.lhs)