plain 0.86.2__tar.gz → 0.88.0__tar.gz

{plain-0.86.2 → plain-0.88.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain
-Version: 0.86.2
+Version: 0.88.0
 Summary: A web framework for building products with Python.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-Expression: BSD-3-Clause

{plain-0.86.2 → plain-0.88.0}/plain/CHANGELOG.md

@@ -1,5 +1,26 @@
 # plain changelog
 
+## [0.88.0](https://github.com/dropseed/plain/releases/plain@0.88.0) (2025-11-13)
+
+### What's changed
+
+- The `plain.forms` module now uses explicit imports instead of wildcard imports, improving IDE autocomplete and type checking support ([eff36f3](https://github.com/dropseed/plain/commit/eff36f31e8e15f84e11164a44c833aeab096ffbd))
+
+### Upgrade instructions
+
+- No changes required
+
+## [0.87.0](https://github.com/dropseed/plain/releases/plain@0.87.0) (2025-11-12)
+
+### What's changed
+
+- Internal classes now use abstract base classes with `@abstractmethod` decorators instead of raising `NotImplementedError`, improving type checking and IDE support ([91b329a](https://github.com/dropseed/plain/commit/91b329a8adb477031c4358e638b12f35f19bb85d), [81b5f88](https://github.com/dropseed/plain/commit/81b5f88a4bd39785f6b19c3c00c0ed23a36fb72f), [d2e2423](https://github.com/dropseed/plain/commit/d2e24235f497a92f45d5a21fc83d802897c2dec0), [61e7b5a](https://github.com/dropseed/plain/commit/61e7b5a0c8675aaaf65f0a626ff7959a786dca7f))
+- Updated to latest version of `ty` type checker and fixed type errors and warnings throughout the codebase ([f4dbcef](https://github.com/dropseed/plain/commit/f4dbcefa929058be517cb1d4ab35bd73a89f26b8))
+
+### Upgrade instructions
+
+- No changes required
+
 ## [0.86.2](https://github.com/dropseed/plain/releases/plain@0.86.2) (2025-11-11)
 
 ### What's changed

{plain-0.86.2 → plain-0.88.0}/plain/assets/views.py

@@ -14,6 +14,7 @@ from plain.http import (
     ResponseRedirect,
     StreamingResponse,
 )
+from plain.http.response import ResponseHeaders
 from plain.runtime import settings
 from plain.urls import reverse
 from plain.views import View
@@ -37,7 +38,7 @@ class AssetView(View):
     def get_url_path(self) -> str:
         return self.asset_path or self.url_kwargs["path"]
 
-    def get(self) -> Response | FileResponse:
+    def get(self) -> Response | FileResponse | StreamingResponse:
         url_path = self.get_url_path()
 
         # Make a trailing slash work, but we don't expect it
@@ -52,7 +53,11 @@ class AssetView(View):
                 if redirect_response := self.get_redirect_response(url_path):
                     return redirect_response
 
+        # check_asset_path validates and raises if path is invalid
+        # After this point, absolute_path is guaranteed to be a valid str
         self.check_asset_path(absolute_path)
+        # Type guard: absolute_path is now str (check_asset_path raises if None/invalid)
+        assert absolute_path is not None
 
         if encoded_path := self.get_encoded_path(absolute_path):
             absolute_path = encoded_path
@@ -127,7 +132,7 @@ class AssetView(View):
     def get_size(self, path: str) -> int:
         return os.path.getsize(path)
 
-    def update_headers(self, headers: dict, path: str) -> dict:
+    def update_headers(self, headers: ResponseHeaders, path: str) -> ResponseHeaders:
         headers.setdefault("Access-Control-Allow-Origin", "*")
 
         # Always vary on Accept-Encoding

{plain-0.86.2 → plain-0.88.0}/plain/cli/agent/request.py

@@ -98,7 +98,7 @@ def request(
 
         # Make the request
         method = method.upper()
-        kwargs: dict[str, object] = {
+        kwargs: dict[str, Any] = {
             "follow": follow,
         }
         if header_dict:

{plain-0.86.2 → plain-0.88.0}/plain/cli/preflight.py

@@ -1,5 +1,6 @@
 import json
 import sys
+from typing import Any
 
 import click
 
@@ -125,12 +126,12 @@ def preflight_cli(deploy: bool, format: str, quiet: bool) -> None:
 
     if format == "json":
         # Build JSON output
-        results = {"passed": not has_errors, "checks": []}
+        results: dict[str, Any] = {"passed": not has_errors, "checks": []}
 
         for check_class, check_name, issues in check_results:
             visible_issues = [issue for issue in issues if not issue.is_silenced()]
 
-            check_result = {
+            check_result: dict[str, Any] = {
                 "name": check_name,
                 "passed": len(visible_issues) == 0,
                 "issues": [],

{plain-0.86.2 → plain-0.88.0}/plain/exceptions.py

@@ -145,7 +145,7 @@ class ValidationError(Exception):
     @property
     def messages(self) -> list[str]:
         if hasattr(self, "error_dict"):
-            return sum(dict(self).values(), [])
+            return sum(dict(self).values(), [])  # type: ignore[call-overload]
         return list(self)
 
     def update_error_dict(
@@ -171,7 +171,7 @@ class ValidationError(Exception):
 
     def __str__(self) -> str:
         if hasattr(self, "error_dict"):
-            return repr(dict(self))
+            return repr(dict(self))  # type: ignore[call-overload]
         return repr(list(self))
 
     def __repr__(self) -> str:

plain-0.88.0/plain/forms/__init__.py

@@ -0,0 +1,59 @@
+"""
+Plain validation and HTML form handling.
+"""
+
+from .boundfield import BoundField
+from .exceptions import FormFieldMissingError, ValidationError
+from .fields import (
+    BooleanField,
+    CharField,
+    ChoiceField,
+    DateField,
+    DateTimeField,
+    DecimalField,
+    DurationField,
+    EmailField,
+    Field,
+    FileField,
+    FloatField,
+    ImageField,
+    IntegerField,
+    JSONField,
+    MultipleChoiceField,
+    NullBooleanField,
+    RegexField,
+    TimeField,
+    TypedChoiceField,
+    URLField,
+    UUIDField,
+)
+from .forms import BaseForm, Form
+
+__all__ = [
+    "BoundField",
+    "FormFieldMissingError",
+    "ValidationError",
+    "BooleanField",
+    "CharField",
+    "ChoiceField",
+    "DateField",
+    "DateTimeField",
+    "DecimalField",
+    "DurationField",
+    "EmailField",
+    "Field",
+    "FileField",
+    "FloatField",
+    "ImageField",
+    "IntegerField",
+    "JSONField",
+    "MultipleChoiceField",
+    "NullBooleanField",
+    "RegexField",
+    "TimeField",
+    "TypedChoiceField",
+    "URLField",
+    "UUIDField",
+    "BaseForm",
+    "Form",
+]

{plain-0.86.2 → plain-0.88.0}/plain/forms/boundfield.py

@@ -58,7 +58,7 @@ class BoundField:
         associated Form has specified auto_id. Return an empty string otherwise.
         """
         auto_id = self._form._auto_id  # Boolean or string
-        if auto_id and "%s" in str(auto_id):
+        if auto_id and isinstance(auto_id, str) and "%s" in auto_id:
             return auto_id % self.html_name
         elif auto_id:
             return self.html_name

{plain-0.86.2 → plain-0.88.0}/plain/forms/fields.py

@@ -11,13 +11,13 @@ import json
 import math
 import re
 import uuid
-from collections.abc import Callable
+from collections.abc import Callable, Iterator, Sequence
 from decimal import Decimal, DecimalException
 from io import BytesIO
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Self
 from urllib.parse import urlsplit, urlunsplit
 
-from plain import validators
+from plain import validators as validators_
 from plain.exceptions import ValidationError
 from plain.utils import timezone
 from plain.utils.dateparse import parse_datetime, parse_duration
@@ -66,7 +66,7 @@ class Field:
     default_error_messages = {
         "required": "This field is required.",
     }
-    empty_values = list(validators.EMPTY_VALUES)
+    empty_values = list(validators_.EMPTY_VALUES)
 
     def __init__(
         self,
@@ -74,7 +74,7 @@ class Field:
         required: bool = True,
         initial: Any = None,
         error_messages: dict[str, str] | None = None,
-        validators: tuple[Callable[[Any], None], ...] = (),
+        validators: Sequence[Callable[[Any], None]] = (),
     ):
         # required -- Boolean that specifies whether the field is required.
         #             True by default.
@@ -144,7 +144,7 @@ class Field:
         try:
             data = self.to_python(data)
             if hasattr(self, "_coerce"):
-                return self._coerce(data) != self._coerce(initial)
+                return self._coerce(data) != self._coerce(initial)  # type: ignore[attr-defined]
         except ValidationError:
             return True
         # For purposes of seeing whether something has changed, None is
@@ -161,7 +161,7 @@ class Field:
         """
         return BoundField(form, self, field_name)
 
-    def __deepcopy__(self, memo: dict[int, Any]) -> Field:
+    def __deepcopy__(self: Self, memo: dict[int, Any]) -> Self:
         result = copy.copy(self)
         memo[id(self)] = result
         result.error_messages = self.error_messages.copy()
@@ -190,18 +190,26 @@ class CharField(Field):
         min_length: int | None = None,
         strip: bool = True,
         empty_value: str = "",
-        **kwargs: Any,
+        required: bool = True,
+        initial: Any = None,
+        error_messages: dict[str, str] | None = None,
+        validators: Sequence[Callable[[Any], None]] = (),
     ):
         self.max_length = max_length
         self.min_length = min_length
         self.strip = strip
         self.empty_value = empty_value
-        super().__init__(**kwargs)
+        super().__init__(
+            required=required,
+            initial=initial,
+            error_messages=error_messages,
+            validators=validators,
+        )
         if min_length is not None:
-            self.validators.append(validators.MinLengthValidator(int(min_length)))
+            self.validators.append(validators_.MinLengthValidator(int(min_length)))
         if max_length is not None:
-            self.validators.append(validators.MaxLengthValidator(int(max_length)))
-        self.validators.append(validators.ProhibitNullCharactersValidator())
+            self.validators.append(validators_.MaxLengthValidator(int(max_length)))
+        self.validators.append(validators_.ProhibitNullCharactersValidator())
 
     def to_python(self, value: Any) -> str:
         """Return a string."""
@@ -226,17 +234,25 @@ class IntegerField(Field):
         max_value: int | None = None,
         min_value: int | None = None,
         step_size: int | None = None,
-        **kwargs: Any,
+        required: bool = True,
+        initial: Any = None,
+        error_messages: dict[str, str] | None = None,
+        validators: Sequence[Callable[[Any], None]] = (),
     ):
         self.max_value, self.min_value, self.step_size = max_value, min_value, step_size
-        super().__init__(**kwargs)
+        super().__init__(
+            required=required,
+            initial=initial,
+            error_messages=error_messages,
+            validators=validators,
+        )
 
         if max_value is not None:
-            self.validators.append(validators.MaxValueValidator(max_value))
+            self.validators.append(validators_.MaxValueValidator(max_value))
         if min_value is not None:
-            self.validators.append(validators.MinValueValidator(min_value))
+            self.validators.append(validators_.MinValueValidator(min_value))
         if step_size is not None:
-            self.validators.append(validators.StepValueValidator(step_size))
+            self.validators.append(validators_.StepValueValidator(step_size))
 
     def to_python(self, value: Any) -> int | None:
         """
@@ -293,11 +309,21 @@ class DecimalField(IntegerField):
         min_value: int | None = None,
         max_digits: int | None = None,
         decimal_places: int | None = None,
-        **kwargs: Any,
+        required: bool = True,
+        initial: Any = None,
+        error_messages: dict[str, str] | None = None,
+        validators: Sequence[Callable[[Any], None]] = (),
     ):
         self.max_digits, self.decimal_places = max_digits, decimal_places
-        super().__init__(max_value=max_value, min_value=min_value, **kwargs)
-        self.validators.append(validators.DecimalValidator(max_digits, decimal_places))
+        super().__init__(
+            max_value=max_value,
+            min_value=min_value,
+            required=required,
+            initial=initial,
+            error_messages=error_messages,
+            validators=validators,
+        )
+        self.validators.append(validators_.DecimalValidator(max_digits, decimal_places))
 
     def to_python(self, value: Any) -> Decimal | None:
         """
@@ -372,8 +398,21 @@ class BaseTemporalField(Field):
         "%m/%d/%y %H:%M",  # '10/25/06 14:30'
     ]
 
-    def __init__(self, *, input_formats: list[str] | None = None, **kwargs: Any):
-        super().__init__(**kwargs)
+    def __init__(
+        self,
+        *,
+        input_formats: list[str] | None = None,
+        required: bool = True,
+        initial: Any = None,
+        error_messages: dict[str, str] | None = None,
+        validators: Sequence[Callable[[Any], None]] = (),
+    ):
+        super().__init__(
+            required=required,
+            initial=initial,
+            error_messages=error_messages,
+            validators=validators,
+        )
         if input_formats is not None:
             self.input_formats = input_formats
 
@@ -506,12 +545,32 @@ class DurationField(Field):
 
 
 class RegexField(CharField):
-    def __init__(self, regex: str | re.Pattern[str], **kwargs: Any) -> None:
+    def __init__(
+        self,
+        regex: str | re.Pattern[str],
+        *,
+        max_length: int | None = None,
+        min_length: int | None = None,
+        strip: bool = False,
+        empty_value: str = "",
+        required: bool = True,
+        initial: Any = None,
+        error_messages: dict[str, str] | None = None,
+        validators: Sequence[Callable[[Any], None]] = (),
+    ) -> None:
         """
         regex can be either a string or a compiled regular expression object.
         """
-        kwargs.setdefault("strip", False)
-        super().__init__(**kwargs)
+        super().__init__(
+            max_length=max_length,
+            min_length=min_length,
+            strip=strip,
+            empty_value=empty_value,
+            required=required,
+            initial=initial,
+            error_messages=error_messages,
+            validators=validators,
+        )
         self._set_regex(regex)
 
     def _get_regex(self) -> re.Pattern[str]:
@@ -526,17 +585,37 @@ class RegexField(CharField):
             and self._regex_validator in self.validators
         ):
             self.validators.remove(self._regex_validator)
-        self._regex_validator = validators.RegexValidator(regex=regex)
+        self._regex_validator = validators_.RegexValidator(regex=regex)
         self.validators.append(self._regex_validator)
 
     regex = property(_get_regex, _set_regex)
 
 
 class EmailField(CharField):
-    default_validators = [validators.validate_email]
+    default_validators = [validators_.validate_email]
 
-    def __init__(self, **kwargs: Any) -> None:
-        super().__init__(strip=True, **kwargs)
+    def __init__(
+        self,
+        *,
+        max_length: int | None = None,
+        min_length: int | None = None,
+        strip: bool = True,
+        empty_value: str = "",
+        required: bool = True,
+        initial: Any = None,
+        error_messages: dict[str, str] | None = None,
+        validators: Sequence[Callable[[Any], None]] = (),
+    ) -> None:
+        super().__init__(
+            max_length=max_length,
+            min_length=min_length,
+            strip=strip,
+            empty_value=empty_value,
+            required=required,
+            initial=initial,
+            error_messages=error_messages,
+            validators=validators,
+        )
 
 
 class FileField(Field):
@@ -557,11 +636,19 @@ class FileField(Field):
         *,
         max_length: int | None = None,
         allow_empty_file: bool = False,
-        **kwargs: Any,
+        required: bool = True,
+        initial: Any = None,
+        error_messages: dict[str, str] | None = None,
+        validators: Sequence[Callable[[Any], None]] = (),
     ) -> None:
         self.max_length = max_length
         self.allow_empty_file = allow_empty_file
-        super().__init__(**kwargs)
+        super().__init__(
+            required=required,
+            initial=initial,
+            error_messages=error_messages,
+            validators=validators,
+        )
 
     def to_python(self, data: Any) -> Any:
         if data in self.empty_values:
@@ -621,7 +708,7 @@ class FileField(Field):
 
 
 class ImageField(FileField):
-    default_validators = [validators.validate_image_file_extension]
+    default_validators = [validators_.validate_image_file_extension]
     default_error_messages = {
         "invalid_image": "Upload a valid image. The file you uploaded was either not an image or a corrupted image.",
     }
@@ -674,10 +761,30 @@ class URLField(CharField):
     default_error_messages = {
         "invalid": "Enter a valid URL.",
     }
-    default_validators = [validators.URLValidator()]
+    default_validators = [validators_.URLValidator()]
 
-    def __init__(self, **kwargs: Any) -> None:
-        super().__init__(strip=True, **kwargs)
+    def __init__(
+        self,
+        *,
+        max_length: int | None = None,
+        min_length: int | None = None,
+        strip: bool = True,
+        empty_value: str = "",
+        required: bool = True,
+        initial: Any = None,
+        error_messages: dict[str, str] | None = None,
+        validators: Sequence[Callable[[Any], None]] = (),
+    ) -> None:
+        super().__init__(
+            max_length=max_length,
+            min_length=min_length,
+            strip=strip,
+            empty_value=empty_value,
+            required=required,
+            initial=initial,
+            error_messages=error_messages,
+            validators=validators,
+        )
 
     def to_python(self, value: Any) -> str:
         def split_url(url: str | bytes) -> list[str]:
@@ -792,7 +899,7 @@ class CallableChoiceIterator:
     def __init__(self, choices_func: Callable[[], Any]) -> None:
         self.choices_func = choices_func
 
-    def __iter__(self) -> Any:
+    def __iter__(self) -> Iterator[Any]:
         yield from self.choices_func()
 
 
@@ -801,8 +908,23 @@ class ChoiceField(Field):
         "invalid_choice": "Select a valid choice. %(value)s is not one of the available choices.",
     }
 
-    def __init__(self, *, choices: Any = (), **kwargs: Any) -> None:
-        super().__init__(**kwargs)
+    _choices: CallableChoiceIterator | list[Any]  # Set by choices property setter
+
+    def __init__(
+        self,
+        *,
+        choices: Any = (),
+        required: bool = True,
+        initial: Any = None,
+        error_messages: dict[str, str] | None = None,
+        validators: Sequence[Callable[[Any], None]] = (),
+    ) -> None:
+        super().__init__(
+            required=required,
+            initial=initial,
+            error_messages=error_messages,
+            validators=validators,
+        )
         if hasattr(choices, "choices"):
             choices = choices.choices
         elif isinstance(choices, enum.EnumMeta):
@@ -814,7 +936,7 @@ class ChoiceField(Field):
         result._choices = copy.deepcopy(self._choices, memo)
         return result
 
-    def _get_choices(self) -> Any:
+    def _get_choices(self) -> CallableChoiceIterator | list[Any]:
         return self._choices
 
     def _set_choices(self, value: Any) -> None:
@@ -867,11 +989,21 @@ class TypedChoiceField(ChoiceField):
         *,
         coerce: Callable[[Any], Any] = lambda val: val,
         empty_value: Any = "",
-        **kwargs: Any,
+        choices: Any = (),
+        required: bool = True,
+        initial: Any = None,
+        error_messages: dict[str, str] | None = None,
+        validators: Sequence[Callable[[Any], None]] = (),
     ) -> None:
         self.coerce = coerce
         self.empty_value = empty_value
-        super().__init__(**kwargs)
+        super().__init__(
+            choices=choices,
+            required=required,
+            initial=initial,
+            error_messages=error_messages,
+            validators=validators,
+        )
 
     def _coerce(self, value: Any) -> Any:
         """
@@ -978,13 +1110,30 @@ class JSONField(CharField):
         decoder: Any = None,
         indent: int | None = None,
         sort_keys: bool = False,
-        **kwargs: Any,
+        *,
+        max_length: int | None = None,
+        min_length: int | None = None,
+        strip: bool = True,
+        empty_value: str = "",
+        required: bool = True,
+        initial: Any = None,
+        error_messages: dict[str, str] | None = None,
+        validators: Sequence[Callable[[Any], None]] = (),
     ) -> None:
         self.encoder = encoder
         self.decoder = decoder
         self.indent = indent
         self.sort_keys = sort_keys
-        super().__init__(**kwargs)
+        super().__init__(
+            max_length=max_length,
+            min_length=min_length,
+            strip=strip,
+            empty_value=empty_value,
+            required=required,
+            initial=initial,
+            error_messages=error_messages,
+            validators=validators,
+        )
 
     def to_python(self, value: Any) -> Any:
         if value in self.empty_values:

{plain-0.86.2 → plain-0.88.0}/plain/forms/forms.py

@@ -65,6 +65,9 @@ class BaseForm:
     class.
     """
 
+    # Set by DeclarativeFieldsMetaclass
+    base_fields: dict[str, Field]
+
     prefix: str | None = None
 
     def __init__(
@@ -139,10 +142,11 @@ class BaseForm:
         return self._bound_fields_cache[name]
 
     @property
-    def errors(self) -> dict[str, list[str]] | None:
+    def errors(self) -> dict[str, list[str]]:
         """Return an error dict for the data provided for the form."""
         if self._errors is None:
             self.full_clean()
+        assert self._errors is not None, "full_clean should initialize _errors"
         return self._errors
 
     def is_valid(self) -> bool:
@@ -213,13 +217,16 @@ class BaseForm:
                     yield next(iter(err))
 
         for field_key, error_list in error_dict.items():
+            # Accessing self.errors ensures _errors is initialized
             if field_key not in self.errors:
                 if field_key != NON_FIELD_ERRORS and field_key not in self.fields:
                     raise ValueError(
                         f"'{self.__class__.__name__}' has no field named '{field_key}'."
                     )
+                assert self._errors is not None, "errors property initializes _errors"
                 self._errors[field_key] = ValidationErrors()
 
+            assert self._errors is not None, "errors property initializes _errors"
             self._errors[field_key].extend(error_list)
 
             # The field had an error, so removed it from the final data

{plain-0.86.2 → plain-0.88.0}/plain/http/multipartparser.py

@@ -424,7 +424,7 @@ class MultiPartParser:
         # (Maybe add handler.free_file to complement new_file)
         for handler in self._upload_handlers:
             if hasattr(handler, "file"):
-                handler.file.close()
+                handler.file.close()  # type: ignore[union-attr]
 
 
 class LazyStream:
@@ -503,7 +503,7 @@ class LazyStream:
         Replace the producer with an empty list. Any leftover bytes that have
         already been read will still be reported upon read() and/or next().
         """
-        self._producer = []
+        self._producer = iter([])
 
     def __iter__(self) -> LazyStream:
         return self