plain 0.69.0__py3-none-any.whl → 0.71.0__py3-none-any.whl

plain/debug.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 from pprint import pformat
+from typing import Any, NoReturn
 
 from markupsafe import Markup, escape
 
@@ -6,7 +9,7 @@ from plain.http import Response
 from plain.views.exceptions import ResponseException
 
 
-def dd(*objs):
+def dd(*objs: Any) -> NoReturn:
     """
     Dump and die.
 
@@ -25,5 +28,5 @@ def dd(*objs):
     response = Response()
     response.status_code = 500
     response.content = combined_dump_str
-    response.content_type = "text/html"
+    response.headers["Content-Type"] = "text/html"
     raise ResponseException(response)

plain/exceptions.py

@@ -2,7 +2,11 @@
 Global Plain exception and warning classes.
 """
 
+from __future__ import annotations
+
 import operator
+from collections.abc import Iterator
+from typing import Any
 
 from plain.utils.hashable import make_hashable
 
@@ -90,7 +94,12 @@ NON_FIELD_ERRORS = "__all__"
 class ValidationError(Exception):
     """An error while validating data."""
 
-    def __init__(self, message, code=None, params=None):
+    def __init__(
+        self,
+        message: str | list[Any] | dict[str, Any] | ValidationError,
+        code: str | None = None,
+        params: dict[str, Any] | None = None,
+    ):
         """
         The `message` argument can be a single error, a list of errors, or a
         dictionary that maps field names to lists of errors. What we define as
@@ -134,12 +143,14 @@ class ValidationError(Exception):
             self.error_list = [self]
 
     @property
-    def messages(self):
+    def messages(self) -> list[str]:
         if hasattr(self, "error_dict"):
             return sum(dict(self).values(), [])
         return list(self)
 
-    def update_error_dict(self, error_dict):
+    def update_error_dict(
+        self, error_dict: dict[str, list[ValidationError]]
+    ) -> dict[str, list[ValidationError]]:
         if hasattr(self, "error_dict"):
             for field, error_list in self.error_dict.items():
                 error_dict.setdefault(field, []).extend(error_list)
@@ -147,7 +158,7 @@ class ValidationError(Exception):
             error_dict.setdefault(NON_FIELD_ERRORS, []).extend(self.error_list)
         return error_dict
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[tuple[str, list[str]] | str]:
         if hasattr(self, "error_dict"):
             for field, errors in self.error_dict.items():
                 yield field, list(ValidationError(errors))
@@ -158,20 +169,20 @@ class ValidationError(Exception):
                     message %= error.params
                 yield str(message)
 
-    def __str__(self):
+    def __str__(self) -> str:
         if hasattr(self, "error_dict"):
             return repr(dict(self))
         return repr(list(self))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"ValidationError({self})"
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if not isinstance(other, ValidationError):
             return NotImplemented
         return hash(self) == hash(other)
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         if hasattr(self, "message"):
             return hash(
                 (

plain/forms/__init__.py

@@ -5,4 +5,4 @@ Plain validation and HTML form handling.
 from .boundfield import BoundField  # NOQA
 from .exceptions import FormFieldMissingError, ValidationError  # NOQA
 from .fields import *  # NOQA
-from .forms import Form  # NOQA
+from .forms import BaseForm, Form  # NOQA

plain/forms/boundfield.py

@@ -1,4 +1,11 @@
+from __future__ import annotations
+
 from functools import cached_property
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .fields import Field
+    from .forms import BaseForm
 
 __all__ = ("BoundField",)
 
@@ -6,24 +13,24 @@ __all__ = ("BoundField",)
 class BoundField:
     "A Field plus data"
 
-    def __init__(self, form, field, name):
+    def __init__(self, form: BaseForm, field: Field, name: str):
         self._form = form
         self.field = field
         self.name = name
         self.html_name = form.add_prefix(name)
         self.html_id = form.add_prefix(self._auto_id)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'<{self.__class__.__name__} "{self.html_name}">'
 
     @property
-    def errors(self):
+    def errors(self) -> list[str]:
         """
         Return an error list (empty if there are no errors) for this field.
         """
         return self._form.errors.get(self.name, [])
 
-    def value(self):
+    def value(self) -> Any:
         """
         Return the value for this BoundField, using the initial value if
         the form is not bound or the data otherwise.
@@ -36,16 +43,16 @@ class BoundField:
         return self.field.prepare_value(data)
 
     @cached_property
-    def initial(self):
+    def initial(self) -> Any:
         return self._form.get_initial_for_field(self.field, self.name)
 
-    def _has_changed(self):
+    def _has_changed(self) -> bool:
         return self.field.has_changed(
             self.initial, self._form._field_data_value(self.field, self.html_name)
         )
 
     @property
-    def _auto_id(self):
+    def _auto_id(self) -> str:
         """
         Calculate and return the ID attribute for this BoundField, if the
         associated Form has specified auto_id. Return an empty string otherwise.

plain/forms/exceptions.py

@@ -2,7 +2,7 @@ from plain.exceptions import ValidationError
 
 
 class FormFieldMissingError(Exception):
-    def __init__(self, field_name):
+    def __init__(self, field_name: str):
         self.field_name = field_name
         self.message = f'The "{self.field_name}" field is missing from the form data.'