plain 0.68.0__py3-none-any.whl → 0.101.2__py3-none-any.whl

plain/forms/fields.py

@@ -2,6 +2,8 @@
 Field classes.
 """
 
+from __future__ import annotations
+
 import copy
 import datetime
 import enum
@@ -9,12 +11,15 @@ import json
 import math
 import re
 import uuid
+from collections.abc import Callable, Iterable, Iterator, Sequence
 from decimal import Decimal, DecimalException
 from io import BytesIO
+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.internal import internalcode
 from plain.utils import timezone
 from plain.utils.dateparse import parse_datetime, parse_duration
 from plain.utils.duration import duration_string
@@ -24,6 +29,9 @@ from plain.utils.text import pluralize_lazy
 from .boundfield import BoundField
 from .exceptions import FormFieldMissingError
 
+if TYPE_CHECKING:
+    from .forms import BaseForm
+
 __all__ = (
     "Field",
     "CharField",
@@ -49,25 +57,25 @@ __all__ = (
 )
 
 
-FILE_INPUT_CONTRADICTION = object()
+_FILE_INPUT_CONTRADICTION = object()
 
 
 class Field:
-    default_validators = []  # Default set of validators
+    default_validators: list[Callable[[Any], None]] = []  # Default set of validators
     # Add an 'invalid' entry to default_error_message if you want a specific
     # field error message not raised by the field validators.
     default_error_messages = {
         "required": "This field is required.",
     }
-    empty_values = list(validators.EMPTY_VALUES)
+    empty_values = list(validators_.EMPTY_VALUES)
 
     def __init__(
         self,
         *,
-        required=True,
-        initial=None,
-        error_messages=None,
-        validators=(),
+        required: bool = True,
+        initial: Any = None,
+        error_messages: dict[str, str] | None = None,
+        validators: Sequence[Callable[[Any], None]] = (),
     ):
         # required -- Boolean that specifies whether the field is required.
         #             True by default.
@@ -87,19 +95,19 @@ class Field:
 
         self.validators = [*self.default_validators, *validators]
 
-    def prepare_value(self, value):
+    def prepare_value(self, value: Any) -> Any:
         return value
 
-    def to_python(self, value):
+    def to_python(self, value: Any) -> Any:
         return value
 
-    def validate(self, value):
+    def validate(self, value: Any) -> None:
         if value in self.empty_values and self.required:
             raise ValidationError(self.error_messages["required"], code="required")
 
-    def run_validators(self, value):
+    def run_validators(self, value: Any) -> None:
         if value in self.empty_values:
-            return
+            return None
         errors = []
         for v in self.validators:
             try:
@@ -111,7 +119,7 @@ class Field:
         if errors:
             raise ValidationError(errors)
 
-    def clean(self, value):
+    def clean(self, value: Any) -> Any:
         """
         Validate the given value and return its "cleaned" value as an
         appropriate Python object. Raise ValidationError for any errors.
@@ -121,7 +129,7 @@ class Field:
         self.run_validators(value)
         return value
 
-    def bound_data(self, data, initial):
+    def bound_data(self, data: Any, initial: Any) -> Any:
         """
         Return the value that should be shown for this field on render of a
         bound form, given the submitted POST data for the field and the initial
@@ -132,12 +140,12 @@ class Field:
         """
         return data
 
-    def has_changed(self, initial, data):
+    def has_changed(self, initial: Any, data: Any) -> bool:
         """Return True if data differs from initial."""
         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[misc]
         except ValidationError:
             return True
         # For purposes of seeing whether something has changed, None is
@@ -147,28 +155,28 @@ class Field:
         data_value = data if data is not None else ""
         return initial_value != data_value
 
-    def get_bound_field(self, form, field_name):
+    def get_bound_field(self, form: BaseForm, field_name: str) -> BoundField:
         """
         Return a BoundField instance that will be used when accessing the form
         field in a template.
         """
         return BoundField(form, self, field_name)
 
-    def __deepcopy__(self, memo):
+    def __deepcopy__(self: Self, memo: dict[int, Any]) -> Self:
         result = copy.copy(self)
         memo[id(self)] = result
         result.error_messages = self.error_messages.copy()
         result.validators = self.validators[:]
         return result
 
-    def value_from_form_data(self, data, files, html_name):
+    def value_from_form_data(self, data: Any, files: Any, html_name: str) -> Any:
         # By default, all fields are expected to be present in HTML form data.
         try:
             return data[html_name]
         except KeyError as e:
             raise FormFieldMissingError(html_name) from e
 
-    def value_from_json_data(self, data, files, html_name):
+    def value_from_json_data(self, data: Any, files: Any, html_name: str) -> Any:
         if self.required and html_name not in data:
             raise FormFieldMissingError(html_name)
 
@@ -177,20 +185,34 @@ class Field:
 
 class CharField(Field):
     def __init__(
-        self, *, max_length=None, min_length=None, strip=True, empty_value="", **kwargs
+        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]] = (),
     ):
         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):
+    def to_python(self, value: Any) -> str:
         """Return a string."""
         if value not in self.empty_values:
             value = str(value)
@@ -201,24 +223,43 @@ class CharField(Field):
         return value
 
 
-class IntegerField(Field):
-    default_error_messages = {
-        "invalid": "Enter a whole number.",
-    }
-    re_decimal = _lazy_re_compile(r"\.0*\s*$")
+class NumericField(Field):
+    """Base class for numeric fields with min/max/step validation."""
 
-    def __init__(self, *, max_value=None, min_value=None, step_size=None, **kwargs):
+    def __init__(
+        self,
+        *,
+        max_value: int | float | Decimal | None = None,
+        min_value: int | float | Decimal | None = None,
+        step_size: int | float | Decimal | None = None,
+        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):
+class IntegerField(NumericField):
+    default_error_messages = {
+        "invalid": "Enter a whole number.",
+    }
+    re_decimal = _lazy_re_compile(r"\.0*\s*$")
+
+    def to_python(self, value: Any) -> int | None:
         """
         Validate that int() can be called on the input. Return the result
         of int() or None for empty values.
@@ -234,17 +275,17 @@ class IntegerField(Field):
         return value
 
 
-class FloatField(IntegerField):
+class FloatField(NumericField):
     default_error_messages = {
         "invalid": "Enter a number.",
     }
 
-    def to_python(self, value):
+    def to_python(self, value: Any) -> float | None:
         """
         Validate that float() can be called on the input. Return the result
         of float() or None for empty values.
         """
-        value = super(IntegerField, self).to_python(value)
+        value = super().to_python(value)
         if value in self.empty_values:
             return None
         try:
@@ -253,15 +294,15 @@ class FloatField(IntegerField):
             raise ValidationError(self.error_messages["invalid"], code="invalid")
         return value
 
-    def validate(self, value):
+    def validate(self, value: Any) -> None:
         super().validate(value)
         if value in self.empty_values:
-            return
+            return None
         if not math.isfinite(value):
             raise ValidationError(self.error_messages["invalid"], code="invalid")
 
 
-class DecimalField(IntegerField):
+class DecimalField(NumericField):
     default_error_messages = {
         "invalid": "Enter a number.",
     }
@@ -269,17 +310,27 @@ class DecimalField(IntegerField):
     def __init__(
         self,
         *,
-        max_value=None,
-        min_value=None,
-        max_digits=None,
-        decimal_places=None,
-        **kwargs,
+        max_value: Decimal | int | None = None,
+        min_value: Decimal | int | None = None,
+        max_digits: int | None = None,
+        decimal_places: int | None = None,
+        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):
+    def to_python(self, value: Any) -> Decimal | None:
         """
         Validate that the input is a decimal number. Return a Decimal
         instance or None for empty values. Ensure that there are no more
@@ -294,10 +345,10 @@ class DecimalField(IntegerField):
             raise ValidationError(self.error_messages["invalid"], code="invalid")
         return value
 
-    def validate(self, value):
+    def validate(self, value: Any) -> None:
         super().validate(value)
         if value in self.empty_values:
-            return
+            return None
         if not value.is_finite():
             raise ValidationError(
                 self.error_messages["invalid"],
@@ -352,12 +403,25 @@ class BaseTemporalField(Field):
         "%m/%d/%y %H:%M",  # '10/25/06 14:30'
     ]
 
-    def __init__(self, *, input_formats=None, **kwargs):
-        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
 
-    def to_python(self, value):
+    def to_python(self, value: Any) -> Any:
         value = value.strip()
         # Try to strptime against each input format.
         for format in self.input_formats:
@@ -367,7 +431,7 @@ class BaseTemporalField(Field):
                 continue
         raise ValidationError(self.error_messages["invalid"], code="invalid")
 
-    def strptime(self, value, format):
+    def strptime(self, value: str, format: str) -> Any:
         raise NotImplementedError("Subclasses must define this method.")
 
 
@@ -377,7 +441,7 @@ class DateField(BaseTemporalField):
         "invalid": "Enter a valid date.",
     }
 
-    def to_python(self, value):
+    def to_python(self, value: Any) -> datetime.date | None:
         """
         Validate that the input can be converted to a date. Return a Python
         datetime.date object.
@@ -390,7 +454,7 @@ class DateField(BaseTemporalField):
             return value
         return super().to_python(value)
 
-    def strptime(self, value, format):
+    def strptime(self, value: str, format: str) -> datetime.date:
         return datetime.datetime.strptime(value, format).date()
 
 
@@ -398,7 +462,7 @@ class TimeField(BaseTemporalField):
     input_formats = BaseTemporalField.TIME_INPUT_FORMATS
     default_error_messages = {"invalid": "Enter a valid time."}
 
-    def to_python(self, value):
+    def to_python(self, value: Any) -> datetime.time | None:
         """
         Validate that the input can be converted to a time. Return a Python
         datetime.time object.
@@ -409,12 +473,13 @@ class TimeField(BaseTemporalField):
             return value
         return super().to_python(value)
 
-    def strptime(self, value, format):
+    def strptime(self, value: str, format: str) -> datetime.time:
         return datetime.datetime.strptime(value, format).time()
 
 
+@internalcode
 class DateTimeFormatsIterator:
-    def __iter__(self):
+    def __iter__(self) -> Any:
         yield from BaseTemporalField.DATETIME_INPUT_FORMATS
         yield from BaseTemporalField.DATE_INPUT_FORMATS
 
@@ -425,12 +490,12 @@ class DateTimeField(BaseTemporalField):
         "invalid": "Enter a valid date/time.",
     }
 
-    def prepare_value(self, value):
+    def prepare_value(self, value: Any) -> Any:
         if isinstance(value, datetime.datetime):
             value = to_current_timezone(value)
         return value
 
-    def to_python(self, value):
+    def to_python(self, value: Any) -> datetime.datetime | None:
         """
         Validate that the input can be converted to a datetime. Return a
         Python datetime.datetime object.
@@ -450,7 +515,7 @@ class DateTimeField(BaseTemporalField):
             result = super().to_python(value)
         return from_current_timezone(result)
 
-    def strptime(self, value, format):
+    def strptime(self, value: str, format: str) -> datetime.datetime:
         return datetime.datetime.strptime(value, format)
 
 
@@ -460,12 +525,12 @@ class DurationField(Field):
         "overflow": "The number of days must be between {min_days} and {max_days}.",
     }
 
-    def prepare_value(self, value):
+    def prepare_value(self, value: Any) -> Any:
         if isinstance(value, datetime.timedelta):
             return duration_string(value)
         return value
 
-    def to_python(self, value):
+    def to_python(self, value: Any) -> datetime.timedelta | None:
         if value in self.empty_values:
             return None
         if isinstance(value, datetime.timedelta):
@@ -486,18 +551,38 @@ class DurationField(Field):
 
 
 class RegexField(CharField):
-    def __init__(self, regex, **kwargs):
+    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):
+    def _get_regex(self) -> re.Pattern[str]:
         return self._regex
 
-    def _set_regex(self, regex):
+    def _set_regex(self, regex: str | re.Pattern[str]) -> None:
         if isinstance(regex, str):
             regex = re.compile(regex)
         self._regex = regex
@@ -506,17 +591,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):
-        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):
@@ -532,19 +637,33 @@ class FileField(Field):
         "contradiction": "Please either submit a file or check the clear checkbox, not both.",
     }
 
-    def __init__(self, *, max_length=None, allow_empty_file=False, **kwargs):
+    def __init__(
+        self,
+        *,
+        max_length: int | None = None,
+        allow_empty_file: bool = False,
+        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):
-        if data in self.empty_values:
+    def to_python(self, value: Any) -> Any:
+        if value in self.empty_values:
             return None
 
         # UploadedFile objects should have name and size attributes.
         try:
-            file_name = data.name
-            file_size = data.size
+            file_name = value.name
+            file_size = value.size
         except AttributeError:
             raise ValidationError(self.error_messages["invalid"], code="invalid")
 
@@ -558,11 +677,11 @@ class FileField(Field):
         if not self.allow_empty_file and not file_size:
             raise ValidationError(self.error_messages["empty"], code="empty")
 
-        return data
+        return value
 
-    def clean(self, data, initial=None):
+    def clean(self, data: Any, initial: Any = None) -> Any:  # type: ignore[override]
         # If the widget got contradictory inputs, we raise a validation error
-        if data is FILE_INPUT_CONTRADICTION:
+        if data is _FILE_INPUT_CONTRADICTION:
             raise ValidationError(
                 self.error_messages["contradiction"], code="contradiction"
             )
@@ -581,45 +700,45 @@ class FileField(Field):
             return initial
         return super().clean(data)
 
-    def bound_data(self, _, initial):
+    def bound_data(self, data: Any, initial: Any) -> Any:
         return initial
 
-    def has_changed(self, initial, data):
+    def has_changed(self, initial: Any, data: Any) -> bool:
         return data is not None
 
-    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 files.get(html_name)
 
-    def value_from_json_data(self, data, files, html_name):
+    def value_from_json_data(self, data: Any, files: Any, html_name: str) -> Any:
         return files.get(html_name)
 
 
 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.",
     }
 
-    def to_python(self, data):
+    def to_python(self, value: Any) -> Any:
         """
         Check that the file-upload field data contains a valid image (GIF, JPG,
         PNG, etc. -- whatever Pillow supports).
         """
-        f = super().to_python(data)
+        f = super().to_python(value)
         if f is None:
             return None
 
-        from PIL import Image
+        from PIL import Image  # type: ignore[import-not-found]
 
         # We need to get a file object for Pillow. We might have a path or we might
         # have to read the data into memory.
-        if hasattr(data, "temporary_file_path"):
-            file = data.temporary_file_path()
+        if hasattr(value, "temporary_file_path"):
+            file = value.temporary_file_path()
         else:
-            if hasattr(data, "read"):
-                file = BytesIO(data.read())
+            if hasattr(value, "read"):
+                file = BytesIO(value.read())
             else:
-                file = BytesIO(data["content"])
+                file = BytesIO(value["content"])
 
         try:
             # load() could spot a truncated JPEG, but it loads the entire
@@ -648,18 +767,41 @@ class URLField(CharField):
     default_error_messages = {
         "invalid": "Enter a valid URL.",
     }
-    default_validators = [validators.URLValidator()]
+    default_validators = [validators_.URLValidator()]
 
-    def __init__(self, **kwargs):
-        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):
-        def split_url(url):
+    def to_python(self, value: Any) -> str:
+        def split_url(url: str | bytes) -> list[str]:
             """
             Return a list of url parts via urlparse.urlsplit(), or raise
             ValidationError for some malformed URLs.
             """
             try:
+                # Ensure url is a string for consistent typing
+                if isinstance(url, bytes):
+                    url = url.decode("utf-8")
                 return list(urlsplit(url))
             except ValueError:
                 # urlparse.urlsplit can raise a ValueError with some
@@ -679,13 +821,16 @@ class URLField(CharField):
                 url_fields[2] = ""
                 # Rebuild the url_fields list, since the domain segment may now
                 # contain the path too.
-                url_fields = split_url(urlunsplit(url_fields))
-            value = urlunsplit(url_fields)
+                url_result = urlunsplit(url_fields)
+                url_fields = split_url(
+                    str(url_result) if isinstance(url_result, bytes) else url_result
+                )
+            value = str(urlunsplit(url_fields))
         return value
 
 
 class BooleanField(Field):
-    def to_python(self, value):
+    def to_python(self, value: Any) -> bool:
         """Return a Python boolean object."""
         # Explicitly check for the string 'False', which is what a hidden field
         # will submit for False. Also check for '0', since this is what
@@ -697,16 +842,18 @@ class BooleanField(Field):
             value = bool(value)
         return super().to_python(value)
 
-    def validate(self, value):
+    def validate(self, value: Any) -> None:
         if not value and self.required:
             raise ValidationError(self.error_messages["required"], code="required")
 
-    def has_changed(self, initial, data):
+    def has_changed(self, initial: Any, data: Any) -> bool:
         # Sometimes data or initial may be a string equivalent of a boolean
         # so we should run it through to_python first to get a boolean value
         return self.to_python(initial) != self.to_python(data)
 
-    def value_from_form_data(self, data, files, html_name):
+    def value_from_form_data(
+        self, data: Any, files: Any, html_name: str
+    ) -> bool | None:
         if html_name not in data:
             # Unselected checkboxes aren't in HTML form data, so return False
             return False
@@ -723,7 +870,7 @@ class BooleanField(Field):
             "on": True,
         }.get(value)
 
-    def value_from_json_data(self, data, files, html_name):
+    def value_from_json_data(self, data: Any, files: Any, html_name: str) -> Any:
         # Boolean fields must be present in the JSON data
         try:
             return data[html_name]
@@ -737,7 +884,7 @@ class NullBooleanField(BooleanField):
     to None.
     """
 
-    def to_python(self, value):
+    def to_python(self, value: Any) -> bool | None:  # type: ignore[override]
         """
         Explicitly check for the string 'True' and 'False', which is what a
         hidden field will submit for True and False, for 'true' and 'false',
@@ -753,15 +900,16 @@ class NullBooleanField(BooleanField):
         else:
             return None
 
-    def validate(self, value):
+    def validate(self, value: Any) -> None:
         pass
 
 
+@internalcode
 class CallableChoiceIterator:
-    def __init__(self, choices_func):
+    def __init__(self, choices_func: Callable[[], Any]) -> None:
         self.choices_func = choices_func
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Any]:
         yield from self.choices_func()
 
 
@@ -770,23 +918,38 @@ class ChoiceField(Field):
         "invalid_choice": "Select a valid choice. %(value)s is not one of the available choices.",
     }
 
-    def __init__(self, *, choices=(), **kwargs):
-        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):
             choices = [(member.value, member.name) for member in choices]
         self.choices = choices
 
-    def __deepcopy__(self, memo):
+    def __deepcopy__(self, memo: dict[int, Any]) -> ChoiceField:
         result = super().__deepcopy__(memo)
         result._choices = copy.deepcopy(self._choices, memo)
         return result
 
-    def _get_choices(self):
+    def _get_choices(self) -> Iterable[Any]:
         return self._choices
 
-    def _set_choices(self, value):
+    def _set_choices(self, value: Any) -> None:
         # Setting choices also sets the choices on the widget.
         # choices can be any iterable, but we call list() on it because
         # it will be consumed more than once.
@@ -799,13 +962,13 @@ class ChoiceField(Field):
 
     choices = property(_get_choices, _set_choices)
 
-    def to_python(self, value):
+    def to_python(self, value: Any) -> str:
         """Return a string."""
         if value in self.empty_values:
             return ""
         return str(value)
 
-    def validate(self, value):
+    def validate(self, value: Any) -> None:
         """Validate that the input is in self.choices."""
         super().validate(value)
         if value and not self.valid_value(value):
@@ -815,7 +978,7 @@ class ChoiceField(Field):
                 params={"value": value},
             )
 
-    def valid_value(self, value):
+    def valid_value(self, value: Any) -> bool:
         """Check to see if the provided value is a valid choice."""
         text_value = str(value)
         for k, v in self.choices:
@@ -831,12 +994,28 @@ class ChoiceField(Field):
 
 
 class TypedChoiceField(ChoiceField):
-    def __init__(self, *, coerce=lambda val: val, empty_value="", **kwargs):
+    def __init__(
+        self,
+        *,
+        coerce: Callable[[Any], Any] = lambda val: val,
+        empty_value: 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):
+    def _coerce(self, value: Any) -> Any:
         """
         Validate that the value can be coerced to the right type (if not empty).
         """
@@ -852,7 +1031,7 @@ class TypedChoiceField(ChoiceField):
             )
         return value
 
-    def clean(self, value):
+    def clean(self, value: Any) -> Any:
         value = super().clean(value)
         return self._coerce(value)
 
@@ -863,7 +1042,7 @@ class MultipleChoiceField(ChoiceField):
         "invalid_list": "Enter a list of values.",
     }
 
-    def to_python(self, value):
+    def to_python(self, value: Any) -> list[str]:  # type: ignore[override]
         if not value:
             return []
         elif not isinstance(value, list | tuple):
@@ -872,7 +1051,7 @@ class MultipleChoiceField(ChoiceField):
             )
         return [str(val) for val in value]
 
-    def validate(self, value):
+    def validate(self, value: Any) -> None:
         """Validate that the input is a list or tuple."""
         if self.required and not value:
             raise ValidationError(self.error_messages["required"], code="required")
@@ -885,7 +1064,7 @@ class MultipleChoiceField(ChoiceField):
                     params={"value": val},
                 )
 
-    def has_changed(self, initial, data):
+    def has_changed(self, initial: Any, data: Any) -> bool:
         if initial is None:
             initial = []
         if data is None:
@@ -896,7 +1075,7 @@ class MultipleChoiceField(ChoiceField):
         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)
 
 
@@ -905,12 +1084,12 @@ class UUIDField(CharField):
         "invalid": "Enter a valid UUID.",
     }
 
-    def prepare_value(self, value):
+    def prepare_value(self, value: Any) -> Any:
         if isinstance(value, uuid.UUID):
             return str(value)
         return value
 
-    def to_python(self, value):
+    def to_python(self, value: Any) -> uuid.UUID | None:  # type: ignore[override]
         value = super().to_python(value)
         if value in self.empty_values:
             return None
@@ -922,10 +1101,12 @@ class UUIDField(CharField):
         return value
 
 
+@internalcode
 class InvalidJSONInput(str):
     pass
 
 
+@internalcode
 class JSONString(str):
     pass
 
@@ -936,15 +1117,37 @@ class JSONField(CharField):
     }
 
     def __init__(
-        self, encoder=None, decoder=None, indent=None, sort_keys=False, **kwargs
-    ):
+        self,
+        encoder: Any = None,
+        decoder: Any = None,
+        indent: int | None = None,
+        sort_keys: bool = False,
+        *,
+        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):
+    def to_python(self, value: Any) -> Any:
         if value in self.empty_values:
             return None
         elif isinstance(value, list | dict | int | float | JSONString):
@@ -962,7 +1165,7 @@ class JSONField(CharField):
         else:
             return converted
 
-    def bound_data(self, data, initial):
+    def bound_data(self, data: Any, initial: Any) -> Any:
         if data is None:
             return None
         try:
@@ -970,7 +1173,7 @@ class JSONField(CharField):
         except json.JSONDecodeError:
             return InvalidJSONInput(data)
 
-    def prepare_value(self, value):
+    def prepare_value(self, value: Any) -> Any:
         if isinstance(value, InvalidJSONInput):
             return value
         return json.dumps(
@@ -981,7 +1184,7 @@ class JSONField(CharField):
             cls=self.encoder,
         )
 
-    def has_changed(self, initial, data):
+    def has_changed(self, initial: Any, data: Any) -> bool:
         if super().has_changed(initial, data):
             return True
         # For purposes of seeing whether something has changed, True isn't the
@@ -991,7 +1194,7 @@ class JSONField(CharField):
         )
 
 
-def from_current_timezone(value):
+def from_current_timezone(value: datetime.datetime | None) -> datetime.datetime | None:
     """
     When time zone support is enabled, convert naive datetimes
     entered in the current time zone to aware datetimes.
@@ -1005,7 +1208,7 @@ def from_current_timezone(value):
         except Exception as exc:
             raise ValidationError(
                 (
-                    "%(datetime)s couldn’t be interpreted "
+                    "%(datetime)s couldn't be interpreted "
                     "in time zone %(current_timezone)s; it "
                     "may be ambiguous or it may not exist."
                 ),
@@ -1015,7 +1218,7 @@ def from_current_timezone(value):
     return value
 
 
-def to_current_timezone(value):
+def to_current_timezone(value: datetime.datetime | None) -> datetime.datetime | None:
     """
     When time zone support is enabled, convert aware datetimes
     to naive datetimes in the current time zone for display.