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

plain/models/deletion.py

@@ -1,7 +1,11 @@
+from __future__ import annotations
+
 from collections import Counter, defaultdict
+from collections.abc import Callable, Generator, Iterable
 from functools import partial, reduce
 from itertools import chain
 from operator import attrgetter, or_
+from typing import TYPE_CHECKING, Any
 
 from plain.models import (
     query_utils,
@@ -9,25 +13,29 @@ from plain.models import (
     transaction,
 )
 from plain.models.db import IntegrityError, db_connection
+from plain.models.meta import Meta
 from plain.models.query import QuerySet
 
+if TYPE_CHECKING:
+    from plain.models.fields import Field
+
 
 class ProtectedError(IntegrityError):
-    def __init__(self, msg, protected_objects):
+    def __init__(self, msg: str, protected_objects: Iterable[Any]) -> None:
         self.protected_objects = protected_objects
         super().__init__(msg, protected_objects)
 
 
 class RestrictedError(IntegrityError):
-    def __init__(self, msg, restricted_objects):
+    def __init__(self, msg: str, restricted_objects: Iterable[Any]) -> None:
         self.restricted_objects = restricted_objects
         super().__init__(msg, restricted_objects)
 
 
-def CASCADE(collector, field, sub_objs):
+def CASCADE(collector: Collector, field: Field, sub_objs: Any) -> None:
     collector.collect(
         sub_objs,
-        source=field.remote_field.model,
+        source=field.remote_field.model,  # type: ignore[attr-defined]
         nullable=field.allow_null,
         fail_on_restricted=False,
     )
@@ -35,84 +43,96 @@ def CASCADE(collector, field, sub_objs):
         collector.add_field_update(field, None, sub_objs)
 
 
-def PROTECT(collector, field, sub_objs):
+def PROTECT(collector: Collector, field: Field, sub_objs: Any) -> None:
     raise ProtectedError(
-        f"Cannot delete some instances of model '{field.remote_field.model.__name__}' because they are "
+        f"Cannot delete some instances of model '{field.remote_field.model.__name__}' because they are "  # type: ignore[attr-defined]
         f"referenced through a protected foreign key: '{sub_objs[0].__class__.__name__}.{field.name}'",
         sub_objs,
     )
 
 
-def RESTRICT(collector, field, sub_objs):
+def RESTRICT(collector: Collector, field: Field, sub_objs: Any) -> None:
     collector.add_restricted_objects(field, sub_objs)
-    collector.add_dependency(field.remote_field.model, field.model)
+    collector.add_dependency(field.remote_field.model, field.model)  # type: ignore[attr-defined]
 
 
-def SET(value):
+def SET(value: Any) -> Callable[[Collector, Field, Any], None]:
     if callable(value):
 
-        def set_on_delete(collector, field, sub_objs):
+        def set_on_delete(collector: Collector, field: Field, sub_objs: Any) -> None:
             collector.add_field_update(field, value(), sub_objs)
 
     else:
 
-        def set_on_delete(collector, field, sub_objs):
+        def set_on_delete(collector: Collector, field: Field, sub_objs: Any) -> None:
             collector.add_field_update(field, value, sub_objs)
 
-    set_on_delete.deconstruct = lambda: ("plain.models.SET", (value,), {})
-    set_on_delete.lazy_sub_objs = True
+    set_on_delete.deconstruct = lambda: ("plain.models.SET", (value,), {})  # type: ignore[attr-defined]
+    set_on_delete.lazy_sub_objs = True  # type: ignore[attr-defined]
     return set_on_delete
 
 
-def SET_NULL(collector, field, sub_objs):
+def SET_NULL(collector: Collector, field: Field, sub_objs: Any) -> None:
     collector.add_field_update(field, None, sub_objs)
 
 
-SET_NULL.lazy_sub_objs = True
+SET_NULL.lazy_sub_objs = True  # type: ignore[attr-defined]
 
 
-def SET_DEFAULT(collector, field, sub_objs):
+def SET_DEFAULT(collector: Collector, field: Field, sub_objs: Any) -> None:
     collector.add_field_update(field, field.get_default(), sub_objs)
 
 
-SET_DEFAULT.lazy_sub_objs = True
+SET_DEFAULT.lazy_sub_objs = True  # type: ignore[attr-defined]
 
 
-def DO_NOTHING(collector, field, sub_objs):
+def DO_NOTHING(collector: Collector, field: Field, sub_objs: Any) -> None:
     pass
 
 
-def get_candidate_relations_to_delete(opts):
+def get_candidate_relations_to_delete(meta: Meta) -> Generator[Any, None, None]:
     # The candidate relations are the ones that come from N-1 and 1-1 relations.
     # N-N  (i.e., many-to-many) relations aren't candidates for deletion.
     return (
         f
-        for f in opts.get_fields(include_hidden=True)
+        for f in meta.get_fields(include_hidden=True)
         if f.auto_created and not f.concrete and f.one_to_many
     )
 
 
 class Collector:
-    def __init__(self, origin=None):
+    def __init__(self, origin: Any = None) -> None:
         # A Model or QuerySet object.
         self.origin = origin
         # Initially, {model: {instances}}, later values become lists.
-        self.data = defaultdict(set)
+        self.data: defaultdict[Any, Any] = defaultdict(set)
         # {(field, value): [instances, …]}
-        self.field_updates = defaultdict(list)
+        self.field_updates: defaultdict[tuple[Field, Any], list[Any]] = defaultdict(
+            list
+        )
         # {model: {field: {instances}}}
-        self.restricted_objects = defaultdict(partial(defaultdict, set))
+        self.restricted_objects: defaultdict[Any, Any] = defaultdict(
+            partial(defaultdict, set)
+        )
         # fast_deletes is a list of queryset-likes that can be deleted without
         # fetching the objects into memory.
-        self.fast_deletes = []
+        self.fast_deletes: list[Any] = []
 
         # Tracks deletion-order dependency for databases without transactions
         # or ability to defer constraint checks. Only concrete model classes
         # should be included, as the dependencies exist only between actual
         # database tables.
-        self.dependencies = defaultdict(set)  # {model: {models}}
+        self.dependencies: defaultdict[Any, set[Any]] = defaultdict(
+            set
+        )  # {model: {models}}
 
-    def add(self, objs, source=None, nullable=False, reverse_dependency=False):
+    def add(
+        self,
+        objs: Iterable[Any],
+        source: Any = None,
+        nullable: bool = False,
+        reverse_dependency: bool = False,
+    ) -> list[Any]:
         """
         Add 'objs' to the collection of objects to be deleted.  If the call is
         the result of a cascade, 'source' should be the model that caused it,
@@ -136,32 +156,34 @@ class Collector:
             self.add_dependency(source, model, reverse_dependency=reverse_dependency)
         return new_objs
 
-    def add_dependency(self, model, dependency, reverse_dependency=False):
+    def add_dependency(
+        self, model: Any, dependency: Any, reverse_dependency: bool = False
+    ) -> None:
         if reverse_dependency:
             model, dependency = dependency, model
         self.dependencies[model].add(dependency)
         self.data.setdefault(dependency, self.data.default_factory())
 
-    def add_field_update(self, field, value, objs):
+    def add_field_update(self, field: Field, value: Any, objs: Iterable[Any]) -> None:
         """
         Schedule a field update. 'objs' must be a homogeneous iterable
         collection of model instances (e.g. a QuerySet).
         """
         self.field_updates[field, value].append(objs)
 
-    def add_restricted_objects(self, field, objs):
+    def add_restricted_objects(self, field: Field, objs: Iterable[Any]) -> None:
         if objs:
             model = objs[0].__class__
             self.restricted_objects[model][field].update(objs)
 
-    def clear_restricted_objects_from_set(self, model, objs):
+    def clear_restricted_objects_from_set(self, model: Any, objs: set[Any]) -> None:
         if model in self.restricted_objects:
             self.restricted_objects[model] = {
                 field: items - objs
                 for field, items in self.restricted_objects[model].items()
             }
 
-    def clear_restricted_objects_from_queryset(self, model, qs):
+    def clear_restricted_objects_from_queryset(self, model: Any, qs: QuerySet) -> None:
         if model in self.restricted_objects:
             objs = set(
                 qs.filter(
@@ -174,7 +196,7 @@ class Collector:
             )
             self.clear_restricted_objects_from_set(model, objs)
 
-    def can_fast_delete(self, objs, from_field=None):
+    def can_fast_delete(self, objs: Any, from_field: Any = None) -> bool:
         """
         Determine if the objects in the given queryset-like or single object
         can be fast-deleted. This can be done if there are no cascades, no
@@ -187,8 +209,8 @@ class Collector:
         """
         if from_field and from_field.remote_field.on_delete is not CASCADE:
             return False
-        if hasattr(objs, "_meta"):
-            model = objs._meta.model
+        if hasattr(objs, "_model_meta"):
+            model = objs._model_meta.model
         elif hasattr(objs, "model") and hasattr(objs, "_raw_delete"):
             model = objs.model
         else:
@@ -196,16 +218,16 @@ class Collector:
 
         # The use of from_field comes from the need to avoid cascade back to
         # parent when parent delete is cascading to child.
-        opts = model._meta
+        meta = model._model_meta
         return (
             # Foreign keys pointing to this model.
             all(
                 related.field.remote_field.on_delete is DO_NOTHING
-                for related in get_candidate_relations_to_delete(opts)
+                for related in get_candidate_relations_to_delete(meta)
             )
         )
 
-    def get_del_batches(self, objs, fields):
+    def get_del_batches(self, objs: list[Any], fields: list[Field]) -> list[list[Any]]:
         """
         Return the objs in suitably sized batches for the used db_connection.
         """
@@ -224,13 +246,13 @@ class Collector:
 
     def collect(
         self,
-        objs,
-        source=None,
-        nullable=False,
-        collect_related=True,
-        reverse_dependency=False,
-        fail_on_restricted=True,
-    ):
+        objs: Iterable[Any],
+        source: Any = None,
+        nullable: bool = False,
+        collect_related: bool = True,
+        reverse_dependency: bool = False,
+        fail_on_restricted: bool = True,
+    ) -> None:
         """
         Add 'objs' to the collection of objects to be deleted as well as all
         parent instances.  'objs' must be a homogeneous iterable collection of
@@ -268,7 +290,7 @@ class Collector:
 
         model_fast_deletes = defaultdict(list)
         protected_objects = defaultdict(list)
-        for related in get_candidate_relations_to_delete(model._meta):
+        for related in get_candidate_relations_to_delete(model._model_meta):
             field = related.field
             on_delete = field.remote_field.on_delete
             if on_delete == DO_NOTHING:
@@ -291,7 +313,7 @@ class Collector:
                         chain.from_iterable(
                             (rf.attname for rf in rel.field.foreign_related_fields)
                             for rel in get_candidate_relations_to_delete(
-                                related_model._meta
+                                related_model._model_meta
                             )
                         )
                     )
@@ -342,7 +364,9 @@ class Collector:
                         set(chain.from_iterable(restricted_objects.values())),
                     )
 
-    def related_objects(self, related_model, related_fields, objs):
+    def related_objects(
+        self, related_model: Any, related_fields: list[Field], objs: Iterable[Any]
+    ) -> QuerySet:
         """
         Get a QuerySet of the related model to objs via related fields.
         """
@@ -350,9 +374,9 @@ class Collector:
             [(f"{related_field.name}__in", objs) for related_field in related_fields],
             connector=query_utils.Q.OR,
         )
-        return related_model._meta.base_queryset.filter(predicate)
+        return related_model._model_meta.base_queryset.filter(predicate)
 
-    def sort(self):
+    def sort(self) -> None:
         sorted_models = []
         concrete_models = set()
         models = list(self.data)
@@ -370,7 +394,7 @@ class Collector:
                 return
         self.data = {model: self.data[model] for model in sorted_models}
 
-    def delete(self):
+    def delete(self) -> tuple[int, dict[str, int]]:
         # sort instance collections
         for model, instances in self.data.items():
             self.data[model] = sorted(instances, key=attrgetter("id"))
@@ -388,15 +412,15 @@ class Collector:
             if self.can_fast_delete(instance):
                 with transaction.mark_for_rollback_on_error():
                     count = sql.DeleteQuery(model).delete_batch([instance.id])
-                setattr(instance, model._meta.get_field("id").attname, None)
-                return count, {model._meta.label: count}
+                setattr(instance, model._model_meta.get_field("id").attname, None)
+                return count, {model.model_options.label: count}
 
         with transaction.atomic(savepoint=False):
             # fast deletes
             for qs in self.fast_deletes:
                 count = qs._raw_delete()
                 if count:
-                    deleted_counter[qs.model._meta.label] += count
+                    deleted_counter[qs.model.model_options.label] += count
 
             # update fields
             for (field, value), instances_list in self.field_updates.items():
@@ -430,9 +454,9 @@ class Collector:
                 id_list = [obj.id for obj in instances]
                 count = query.delete_batch(id_list)
                 if count:
-                    deleted_counter[model._meta.label] += count
+                    deleted_counter[model.model_options.label] += count
 
         for model, instances in self.data.items():
             for instance in instances:
-                setattr(instance, model._meta.get_field("id").attname, None)
+                setattr(instance, model._model_meta.get_field("id").attname, None)
         return sum(deleted_counter.values()), dict(deleted_counter)

plain/models/entrypoints.py

@@ -1,4 +1,4 @@
-def setup():
+def setup() -> None:
     # This package isn't an installed app,
     # so we need to trigger our own import and cli registration.
     from .cli import cli  # noqa

plain/models/enums.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 import enum
 from types import DynamicClassAttribute
+from typing import Any
 
 from plain.utils.functional import Promise
 
@@ -9,7 +12,13 @@ __all__ = ["Choices", "IntegerChoices", "TextChoices"]
 class ChoicesMeta(enum.EnumMeta):
     """A metaclass for creating a enum choices."""
 
-    def __new__(metacls, classname, bases, classdict, **kwds):
+    def __new__(
+        metacls: type,
+        classname: str,
+        bases: tuple[type, ...],
+        classdict: Any,
+        **kwds: Any,
+    ) -> type:
         labels = []
         for key in classdict._member_names:
             value = classdict[key]
@@ -26,33 +35,33 @@ class ChoicesMeta(enum.EnumMeta):
             # Use dict.__setitem__() to suppress defenses against double
             # assignment in enum's classdict.
             dict.__setitem__(classdict, key, value)
-        cls = super().__new__(metacls, classname, bases, classdict, **kwds)
+        cls = super().__new__(metacls, classname, bases, classdict, **kwds)  # type: ignore[misc]
         for member, label in zip(cls.__members__.values(), labels):
             member._label_ = label
         return enum.unique(cls)
 
-    def __contains__(cls, member):
+    def __contains__(cls, member: object) -> bool:
         if not isinstance(member, enum.Enum):
             # Allow non-enums to match against member values.
             return any(x.value == member for x in cls)
         return super().__contains__(member)
 
     @property
-    def names(cls):
+    def names(cls) -> list[str]:
         empty = ["__empty__"] if hasattr(cls, "__empty__") else []
         return empty + [member.name for member in cls]
 
     @property
-    def choices(cls):
+    def choices(cls) -> list[tuple[Any, str]]:
         empty = [(None, cls.__empty__)] if hasattr(cls, "__empty__") else []
         return empty + [(member.value, member.label) for member in cls]
 
     @property
-    def labels(cls):
+    def labels(cls) -> list[str]:
         return [label for _, label in cls.choices]
 
     @property
-    def values(cls):
+    def values(cls) -> list[Any]:
         return [value for value, _ in cls.choices]
 
 
@@ -60,10 +69,10 @@ class Choices(enum.Enum, metaclass=ChoicesMeta):
     """Class for creating enumerated choices."""
 
     @DynamicClassAttribute
-    def label(self):
+    def label(self) -> str:
         return self._label_
 
-    def __str__(self):
+    def __str__(self) -> str:
         """
         Use value when cast to str, so that Choices set as model instance
         attributes are rendered as expected in templates and similar contexts.
@@ -71,7 +80,7 @@ class Choices(enum.Enum, metaclass=ChoicesMeta):
         return str(self.value)
 
     # A similar format was proposed for Python 3.10.
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{self.__class__.__qualname__}.{self._name_}"
 
 
@@ -84,5 +93,7 @@ class IntegerChoices(int, Choices):
 class TextChoices(str, Choices):
     """Class for creating enumerated string choices."""
 
-    def _generate_next_value_(name, start, count, last_values):
+    def _generate_next_value_(
+        name: str, start: int, count: int, last_values: list[str]
+    ) -> str:
         return name

plain/models/exceptions.py

@@ -1,4 +1,12 @@
-from typing import Any
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, TypeVar
+
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+
+F = TypeVar("F", bound=Callable[..., Any])
 
 # MARK: Database Query Exceptions
 
@@ -152,7 +160,7 @@ class DatabaseErrorWrapper:
     exceptions using Plain's common wrappers.
     """
 
-    def __init__(self, wrapper):
+    def __init__(self, wrapper: BaseDatabaseWrapper) -> None:
         """
         wrapper is a database wrapper.
 
@@ -160,10 +168,15 @@ class DatabaseErrorWrapper:
         """
         self.wrapper = wrapper
 
-    def __enter__(self):
+    def __enter__(self) -> None:
         pass
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: Any,
+    ) -> None:
         if exc_type is None:
             return
         for plain_exc_type in (
@@ -179,18 +192,20 @@ class DatabaseErrorWrapper:
         ):
             db_exc_type = getattr(self.wrapper.Database, plain_exc_type.__name__)
             if issubclass(exc_type, db_exc_type):
-                plain_exc_value = plain_exc_type(*exc_value.args)
+                plain_exc_value = (
+                    plain_exc_type(*exc_value.args) if exc_value else plain_exc_type()
+                )
                 # Only set the 'errors_occurred' flag for errors that may make
                 # the connection unusable.
                 if plain_exc_type not in (DataError, IntegrityError):
                     self.wrapper.errors_occurred = True
                 raise plain_exc_value.with_traceback(traceback) from exc_value
 
-    def __call__(self, func):
+    def __call__(self, func: F) -> F:
         # Note that we are intentionally not using @wraps here for performance
         # reasons. Refs #21109.
-        def inner(*args, **kwargs):
+        def inner(*args: Any, **kwargs: Any) -> Any:
             with self:
                 return func(*args, **kwargs)
 
-        return inner
+        return inner  # type: ignore[return-value]