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

plain/models/fields/reverse_related.py

@@ -9,7 +9,10 @@ They also act as reverse fields for the purposes of the Meta API because
 they're the closest concept currently available.
 """
 
+from __future__ import annotations
+
 from functools import cached_property
+from typing import Any
 
 from plain.models.exceptions import FieldDoesNotExist, FieldError
 from plain.utils.hashable import make_hashable
@@ -38,12 +41,12 @@ class ForeignObjectRel(FieldCacheMixin):
 
     def __init__(
         self,
-        field,
-        to,
-        related_name=None,
-        related_query_name=None,
-        limit_choices_to=None,
-        on_delete=None,
+        field: Any,
+        to: Any,
+        related_name: str | None = None,
+        related_query_name: str | None = None,
+        limit_choices_to: Any = None,
+        on_delete: Any = None,
     ):
         self.field = field
         self.model = to
@@ -60,19 +63,19 @@ class ForeignObjectRel(FieldCacheMixin):
     # before field.contribute_to_class() has been called will result in
     # AttributeError
     @cached_property
-    def hidden(self):
+    def hidden(self) -> bool:
         return self.is_hidden()
 
     @cached_property
-    def name(self):
+    def name(self) -> str:
         return self.field.related_query_name()
 
     @property
-    def remote_field(self):
+    def remote_field(self) -> Any:
         return self.field
 
     @property
-    def target_field(self):
+    def target_field(self) -> Any:
         """
         When filtering against this relation, return the field on the remote
         model against which the filtering should happen.
@@ -83,7 +86,7 @@ class ForeignObjectRel(FieldCacheMixin):
         return target_fields[0]
 
     @cached_property
-    def related_model(self):
+    def related_model(self) -> Any:
         if not self.field.model:
             raise AttributeError(
                 "This property can't be accessed before self.field.contribute_to_class "
@@ -92,32 +95,32 @@ class ForeignObjectRel(FieldCacheMixin):
         return self.field.model
 
     @cached_property
-    def many_to_many(self):
+    def many_to_many(self) -> bool:
         return self.field.many_to_many
 
     @cached_property
-    def many_to_one(self):
+    def many_to_one(self) -> bool:
         return self.field.one_to_many
 
     @cached_property
-    def one_to_many(self):
+    def one_to_many(self) -> bool:
         return self.field.many_to_one
 
-    def get_lookup(self, lookup_name):
+    def get_lookup(self, lookup_name: str) -> Any:
         return self.field.get_lookup(lookup_name)
 
-    def get_internal_type(self):
+    def get_internal_type(self) -> str:
         return self.field.get_internal_type()
 
     @property
-    def db_type(self):
+    def db_type(self) -> Any:
         return self.field.db_type
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<{type(self).__name__}: {self.related_model._meta.package_label}.{self.related_model._meta.model_name}>"
 
     @property
-    def identity(self):
+    def identity(self) -> tuple[Any, ...]:
         return (
             self.field,
             self.model,
@@ -129,15 +132,15 @@ class ForeignObjectRel(FieldCacheMixin):
             self.multiple,
         )
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if not isinstance(other, self.__class__):
             return NotImplemented
         return self.identity == other.identity
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self.identity)
 
-    def __getstate__(self):
+    def __getstate__(self) -> dict[str, Any]:
         state = self.__dict__.copy()
         # Delete the path_infos cached property because it can be recalculated
         # at first invocation after deserialization. The attribute must be
@@ -151,11 +154,11 @@ class ForeignObjectRel(FieldCacheMixin):
 
     def get_choices(
         self,
-        include_blank=True,
-        blank_choice=BLANK_CHOICE_DASH,
-        limit_choices_to=None,
-        ordering=(),
-    ):
+        include_blank: bool = True,
+        blank_choice: list[tuple[str, str]] = BLANK_CHOICE_DASH,
+        limit_choices_to: Any = None,
+        ordering: tuple[str, ...] = (),
+    ) -> list[tuple[Any, str]]:
         """
         Return choices with a default blank choices included, for use
         as <select> choices for this field.
@@ -169,17 +172,17 @@ class ForeignObjectRel(FieldCacheMixin):
             qs = qs.order_by(*ordering)
         return (blank_choice if include_blank else []) + [(x.id, str(x)) for x in qs]
 
-    def is_hidden(self):
+    def is_hidden(self) -> bool:
         """Should the related object be hidden?"""
         return not self.related_name
 
-    def get_joining_columns(self):
+    def get_joining_columns(self) -> Any:
         return self.field.get_reverse_joining_columns()
 
-    def get_extra_restriction(self, alias, related_alias):
+    def get_extra_restriction(self, alias: str, related_alias: str) -> Any:
         return self.field.get_extra_restriction(related_alias, alias)
 
-    def set_field_name(self):
+    def set_field_name(self) -> None:
         """
         Set the related field's name, this is not available until later stages
         of app loading, so set_field_name is called from
@@ -189,7 +192,7 @@ class ForeignObjectRel(FieldCacheMixin):
         # example custom multicolumn joins currently have no remote field).
         self.field_name = None
 
-    def get_accessor_name(self, model=None):
+    def get_accessor_name(self, model: Any = None) -> str | None:
         # This method encapsulates the logic that decides what name to give an
         # accessor descriptor that retrieves related many-to-one or
         # many-to-many objects.
@@ -204,17 +207,17 @@ class ForeignObjectRel(FieldCacheMixin):
             return self.related_name
         return None
 
-    def get_path_info(self, filtered_relation=None):
+    def get_path_info(self, filtered_relation: Any = None) -> Any:
         if filtered_relation:
             return self.field.get_reverse_path_info(filtered_relation)
         else:
             return self.field.reverse_path_infos
 
     @cached_property
-    def path_infos(self):
+    def path_infos(self) -> Any:
         return self.get_path_info()
 
-    def get_cache_name(self):
+    def get_cache_name(self) -> str | None:
         """
         Return the name of the cache key to use for storing an instance of the
         forward model on the reverse model.
@@ -239,12 +242,12 @@ class ManyToOneRel(ForeignObjectRel):
 
     def __init__(
         self,
-        field,
-        to,
-        related_name=None,
-        related_query_name=None,
-        limit_choices_to=None,
-        on_delete=None,
+        field: Any,
+        to: Any,
+        related_name: str | None = None,
+        related_query_name: str | None = None,
+        limit_choices_to: Any = None,
+        on_delete: Any = None,
     ):
         super().__init__(
             field,
@@ -257,16 +260,16 @@ class ManyToOneRel(ForeignObjectRel):
 
         self.field_name = "id"
 
-    def __getstate__(self):
+    def __getstate__(self) -> dict[str, Any]:
         state = super().__getstate__()
         state.pop("related_model", None)
         return state
 
     @property
-    def identity(self):
+    def identity(self) -> tuple[Any, ...]:
         return super().identity + (self.field_name,)
 
-    def get_related_field(self):
+    def get_related_field(self) -> Any:
         """
         Return the Field in the 'to' object to which this relationship is tied.
         """
@@ -275,7 +278,7 @@ class ManyToOneRel(ForeignObjectRel):
             raise FieldDoesNotExist("No related field named 'id'")
         return field
 
-    def set_field_name(self):
+    def set_field_name(self) -> None:
         pass
 
 
@@ -289,15 +292,15 @@ class ManyToManyRel(ForeignObjectRel):
 
     def __init__(
         self,
-        field,
-        to,
+        field: Any,
+        to: Any,
         *,
-        through,
-        through_fields=None,
-        related_name=None,
-        related_query_name=None,
-        limit_choices_to=None,
-        symmetrical=True,
+        through: Any,
+        through_fields: tuple[str, str] | None = None,
+        related_name: str | None = None,
+        related_query_name: str | None = None,
+        limit_choices_to: Any = None,
+        symmetrical: bool = True,
     ):
         super().__init__(
             field,
@@ -314,14 +317,14 @@ class ManyToManyRel(ForeignObjectRel):
         self.db_constraint = True
 
     @property
-    def identity(self):
+    def identity(self) -> tuple[Any, ...]:
         return super().identity + (
             self.through,
             make_hashable(self.through_fields),
             self.db_constraint,
         )
 
-    def get_related_field(self):
+    def get_related_field(self) -> Any:
         """
         Return the field in the 'to' object to which this relationship is tied.
         Provided for symmetry with ManyToOneRel.

plain/models/forms.py

@@ -3,7 +3,10 @@ Helper functions for creating Form classes from Plain models
 and database field objects.
 """
 
+from __future__ import annotations
+
 from itertools import chain
+from typing import TYPE_CHECKING, Any
 
 from plain.exceptions import (
     NON_FIELD_ERRORS,
@@ -15,6 +18,9 @@ from plain.forms.fields import ChoiceField, Field
 from plain.forms.forms import BaseForm, DeclarativeFieldsMetaclass
 from plain.models.exceptions import FieldError
 
+if TYPE_CHECKING:
+    from plain.models.fields import Field as ModelField
+
 __all__ = (
     "ModelForm",
     "BaseModelForm",
@@ -25,7 +31,11 @@ __all__ = (
 )
 
 
-def construct_instance(form, instance, fields=None):
+def construct_instance(
+    form: BaseModelForm,
+    instance: Any,
+    fields: list[str] | tuple[str, ...] | None = None,
+) -> Any:
     """
     Construct and return a model instance from the bound ``form``'s
     ``cleaned_data``, but do not save the returned instance to the database.
@@ -65,7 +75,9 @@ def construct_instance(form, instance, fields=None):
 # ModelForms #################################################################
 
 
-def model_to_dict(instance, fields=None):
+def model_to_dict(
+    instance: Any, fields: list[str] | tuple[str, ...] | None = None
+) -> dict[str, Any]:
     """
     Return a dict containing the data in ``instance`` suitable for passing as
     a Form's ``initial`` keyword argument.
@@ -83,12 +95,12 @@ def model_to_dict(instance, fields=None):
 
 
 def fields_for_model(
-    model,
-    fields=None,
-    formfield_callback=None,
-    error_messages=None,
-    field_classes=None,
-):
+    model: type[Any],
+    fields: list[str] | tuple[str, ...] | None = None,
+    formfield_callback: Any = None,
+    error_messages: dict[str, Any] | None = None,
+    field_classes: dict[str, type[Field]] | None = None,
+) -> dict[str, Field | None]:
     """
     Return a dictionary containing form fields for the given model.
 
@@ -135,17 +147,28 @@ def fields_for_model(
 
 
 class ModelFormOptions:
-    def __init__(self, options=None):
-        self.model = getattr(options, "model", None)
-        self.fields = getattr(options, "fields", None)
-        self.error_messages = getattr(options, "error_messages", None)
-        self.field_classes = getattr(options, "field_classes", None)
-        self.formfield_callback = getattr(options, "formfield_callback", None)
+    def __init__(self, options: Any = None) -> None:
+        self.model: type[Any] | None = getattr(options, "model", None)
+        self.fields: list[str] | tuple[str, ...] | None = getattr(
+            options, "fields", None
+        )
+        self.error_messages: dict[str, Any] | None = getattr(
+            options, "error_messages", None
+        )
+        self.field_classes: dict[str, type[Field]] | None = getattr(
+            options, "field_classes", None
+        )
+        self.formfield_callback: Any = getattr(options, "formfield_callback", None)
 
 
 class ModelFormMetaclass(DeclarativeFieldsMetaclass):
-    def __new__(mcs, name, bases, attrs):
-        new_class = super().__new__(mcs, name, bases, attrs)
+    def __new__(
+        mcs: type[ModelFormMetaclass],
+        name: str,
+        bases: tuple[type, ...],
+        attrs: dict[str, Any],
+    ) -> type[BaseModelForm]:
+        new_class = super().__new__(mcs, name, bases, attrs)  # type: ignore[invalid-super-argument]
 
         if bases == (BaseModelForm,):
             return new_class
@@ -203,12 +226,12 @@ class BaseModelForm(BaseForm):
     def __init__(
         self,
         *,
-        request,
-        auto_id="id_%s",
-        prefix=None,
-        initial=None,
-        instance=None,
-    ):
+        request: Any,
+        auto_id: str = "id_%s",
+        prefix: str | None = None,
+        initial: dict[str, Any] | None = None,
+        instance: Any = None,
+    ) -> None:
         opts = self._meta
         if opts.model is None:
             raise ValueError("ModelForm has no model class specified.")
@@ -233,7 +256,7 @@ class BaseModelForm(BaseForm):
             initial=object_data,
         )
 
-    def _get_validation_exclusions(self):
+    def _get_validation_exclusions(self) -> set[str]:
         """
         For backwards-compatibility, exclude several types of fields from model
         validation. See tickets #12507, #12521, #12553.
@@ -276,11 +299,11 @@ class BaseModelForm(BaseForm):
                     exclude.add(f.name)
         return exclude
 
-    def clean(self):
+    def clean(self) -> dict[str, Any]:
         self._validate_unique = True
         return self.cleaned_data
 
-    def _update_errors(self, errors):
+    def _update_errors(self, errors: ValidationError) -> None:
         # Override any validation error messages defined at the model level
         # with those defined at the form level.
         opts = self._meta
@@ -313,7 +336,7 @@ class BaseModelForm(BaseForm):
 
         self.add_error(None, errors)
 
-    def _post_clean(self):
+    def _post_clean(self) -> None:
         opts = self._meta
 
         exclude = self._get_validation_exclusions()
@@ -332,7 +355,7 @@ class BaseModelForm(BaseForm):
         if self._validate_unique:
             self.validate_unique()
 
-    def validate_unique(self):
+    def validate_unique(self) -> None:
         """
         Call the instance's validate_unique() method and update the form's
         validation errors if any were raised.
@@ -343,7 +366,7 @@ class BaseModelForm(BaseForm):
         except ValidationError as e:
             self._update_errors(e)
 
-    def _save_m2m(self):
+    def _save_m2m(self) -> None:
         """
         Save the many-to-many fields and generic relations for this form.
         """
@@ -359,7 +382,7 @@ class BaseModelForm(BaseForm):
             if f.name in cleaned_data:
                 f.save_form_data(self.instance, cleaned_data[f.name])
 
-    def save(self, commit=True):
+    def save(self, commit: bool = True) -> Any:
         """
         Save this form's self.instance object if commit=True. Otherwise, add
         a save_m2m() method to the form which can be called after the instance
@@ -391,28 +414,28 @@ class ModelForm(BaseModelForm, metaclass=ModelFormMetaclass):
 
 
 class ModelChoiceIteratorValue:
-    def __init__(self, value, instance):
+    def __init__(self, value: Any, instance: Any) -> None:
         self.value = value
         self.instance = instance
 
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self.value)
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self.value)
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if isinstance(other, ModelChoiceIteratorValue):
             other = other.value
         return self.value == other
 
 
 class ModelChoiceIterator:
-    def __init__(self, field):
+    def __init__(self, field: ModelChoiceField) -> None:
         self.field = field
         self.queryset = field.queryset
 
-    def __iter__(self):
+    def __iter__(self) -> Any:
         if self.field.empty_label is not None:
             yield ("", self.field.empty_label)
         queryset = self.queryset
@@ -422,16 +445,16 @@ class ModelChoiceIterator:
         for obj in queryset:
             yield self.choice(obj)
 
-    def __len__(self):
+    def __len__(self) -> int:
         # count() adds a query but uses less memory since the QuerySet results
         # won't be cached. In most cases, the choices will only be iterated on,
         # and __len__() won't be called.
         return self.queryset.count() + (1 if self.field.empty_label is not None else 0)
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return self.field.empty_label is not None or self.queryset.exists()
 
-    def choice(self, obj):
+    def choice(self, obj: Any) -> tuple[ModelChoiceIteratorValue, str]:
         return (
             ModelChoiceIteratorValue(self.field.prepare_value(obj), obj),
             str(obj),
@@ -450,13 +473,13 @@ class ModelChoiceField(ChoiceField):
 
     def __init__(
         self,
-        queryset,
+        queryset: Any,
         *,
-        empty_label="---------",
-        required=True,
-        initial=None,
-        **kwargs,
-    ):
+        empty_label: str | None = "---------",
+        required: bool = True,
+        initial: Any = None,
+        **kwargs: Any,
+    ) -> None:
         # Call Field instead of ChoiceField __init__() because we don't need
         # ChoiceField.__init__().
         Field.__init__(
@@ -471,22 +494,22 @@ class ModelChoiceField(ChoiceField):
             self.empty_label = empty_label
         self.queryset = queryset
 
-    def __deepcopy__(self, memo):
+    def __deepcopy__(self, memo: dict[int, Any]) -> ModelChoiceField:
         result = super(ChoiceField, self).__deepcopy__(memo)
         # Need to force a new ModelChoiceIterator to be created, bug #11183
         if self.queryset is not None:
             result.queryset = self.queryset.all()
         return result
 
-    def _get_queryset(self):
+    def _get_queryset(self) -> Any:
         return self._queryset
 
-    def _set_queryset(self, queryset):
+    def _set_queryset(self, queryset: Any) -> None:
         self._queryset = None if queryset is None else queryset.all()
 
     queryset = property(_get_queryset, _set_queryset)
 
-    def _get_choices(self):
+    def _get_choices(self) -> ModelChoiceIterator:
         # If self._choices is set, then somebody must have manually set
         # the property self.choices. In this case, just return self._choices.
         if hasattr(self, "_choices"):
@@ -503,12 +526,12 @@ class ModelChoiceField(ChoiceField):
 
     choices = property(_get_choices, ChoiceField._set_choices)
 
-    def prepare_value(self, value):
+    def prepare_value(self, value: Any) -> Any:
         if hasattr(value, "_meta"):
             return value.id
         return super().prepare_value(value)
 
-    def to_python(self, value):
+    def to_python(self, value: Any) -> Any:
         if value in self.empty_values:
             return None
         try:
@@ -524,10 +547,10 @@ class ModelChoiceField(ChoiceField):
             )
         return value
 
-    def validate(self, value):
+    def validate(self, value: Any) -> None:
         return Field.validate(self, value)
 
-    def has_changed(self, initial, data):
+    def has_changed(self, initial: Any, data: Any) -> bool:
         initial_value = initial if initial is not None else ""
         data_value = data if data is not None else ""
         return str(self.prepare_value(initial_value)) != str(data_value)
@@ -542,15 +565,15 @@ class ModelMultipleChoiceField(ModelChoiceField):
         "invalid_id_value": "'%(id)s' is not a valid value.",
     }
 
-    def __init__(self, queryset, **kwargs):
+    def __init__(self, queryset: Any, **kwargs: Any) -> None:
         super().__init__(queryset, empty_label=None, **kwargs)
 
-    def to_python(self, value):
+    def to_python(self, value: Any) -> list[Any]:
         if not value:
             return []
         return list(self._check_values(value))
 
-    def clean(self, value):
+    def clean(self, value: Any) -> Any:
         value = self.prepare_value(value)
         if self.required and not value:
             raise ValidationError(self.error_messages["required"], code="required")
@@ -567,7 +590,7 @@ class ModelMultipleChoiceField(ModelChoiceField):
         self.run_validators(value)
         return qs
 
-    def _check_values(self, value):
+    def _check_values(self, value: Any) -> Any:
         """
         Given a list of possible PK values, return a QuerySet of the
         corresponding objects. Raise a ValidationError if a given value is
@@ -603,7 +626,7 @@ class ModelMultipleChoiceField(ModelChoiceField):
                 )
         return qs
 
-    def prepare_value(self, value):
+    def prepare_value(self, value: Any) -> Any:
         if (
             hasattr(value, "__iter__")
             and not isinstance(value, str)
@@ -613,7 +636,7 @@ class ModelMultipleChoiceField(ModelChoiceField):
             return [prepare_value(v) for v in value]
         return super().prepare_value(value)
 
-    def has_changed(self, initial, data):
+    def has_changed(self, initial: Any, data: Any) -> bool:
         if initial is None:
             initial = []
         if data is None:
@@ -624,13 +647,16 @@ class ModelMultipleChoiceField(ModelChoiceField):
         data_set = {str(value) for value in data}
         return data_set != initial_set
 
-    def value_from_form_data(self, data, files, html_name):
+    def value_from_form_data(self, data: Any, files: Any, html_name: str) -> Any:
         return data.getlist(html_name)
 
 
 def modelfield_to_formfield(
-    modelfield, form_class=None, choices_form_class=None, **kwargs
-):
+    modelfield: ModelField,
+    form_class: type[Field] | None = None,
+    choices_form_class: type[Field] | None = None,
+    **kwargs: Any,
+) -> Field | None:
     defaults = {
         "required": modelfield.required,
     }
@@ -694,7 +720,7 @@ def modelfield_to_formfield(
             **defaults,
         )
 
-    if issubclass(modelfield.__class__, models.fields.PositiveIntegerRelDbTypeMixin):
+    if issubclass(modelfield.__class__, models.fields.PositiveIntegerRelDbTypeMixin):  # type: ignore[attr-defined]
         return fields.IntegerField(min_value=0, **defaults)
 
     if isinstance(modelfield, models.TextField):
@@ -721,7 +747,7 @@ def modelfield_to_formfield(
 
     if isinstance(modelfield, models.ForeignKey):
         return ModelChoiceField(
-            queryset=modelfield.remote_field.model.query,
+            queryset=modelfield.remote_field.model.query,  # type: ignore[attr-defined]
             **defaults,
         )