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

plain/models/constraints.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 from enum import Enum
 from types import NoneType
+from typing import Any
 
 from plain.exceptions import ValidationError
 from plain.models.exceptions import FieldError
@@ -13,13 +16,17 @@ __all__ = ["BaseConstraint", "CheckConstraint", "Deferrable", "UniqueConstraint"
 
 
 class BaseConstraint:
-    default_violation_error_message = "Constraint “%(name)s” is violated."
-    violation_error_code = None
-    violation_error_message = None
+    default_violation_error_message = 'Constraint "%(name)s" is violated.'
+    violation_error_code: str | None = None
+    violation_error_message: str | None = None
 
     def __init__(
-        self, *, name, violation_error_code=None, violation_error_message=None
-    ):
+        self,
+        *,
+        name: str,
+        violation_error_code: str | None = None,
+        violation_error_message: str | None = None,
+    ) -> None:
         self.name = name
         if violation_error_code is not None:
             self.violation_error_code = violation_error_code
@@ -29,28 +36,30 @@ class BaseConstraint:
             self.violation_error_message = self.default_violation_error_message
 
     @property
-    def contains_expressions(self):
+    def contains_expressions(self) -> bool:
         return False
 
-    def constraint_sql(self, model, schema_editor):
+    def constraint_sql(self, model: Any, schema_editor: Any) -> str:
         raise NotImplementedError("This method must be implemented by a subclass.")
 
-    def create_sql(self, model, schema_editor):
+    def create_sql(self, model: Any, schema_editor: Any) -> str:
         raise NotImplementedError("This method must be implemented by a subclass.")
 
-    def remove_sql(self, model, schema_editor):
+    def remove_sql(self, model: Any, schema_editor: Any) -> str:
         raise NotImplementedError("This method must be implemented by a subclass.")
 
-    def validate(self, model, instance, exclude=None):
+    def validate(
+        self, model: Any, instance: Any, exclude: set[str] | None = None
+    ) -> None:
         raise NotImplementedError("This method must be implemented by a subclass.")
 
-    def get_violation_error_message(self):
-        return self.violation_error_message % {"name": self.name}
+    def get_violation_error_message(self) -> str:
+        return self.violation_error_message % {"name": self.name}  # type: ignore[operator]
 
-    def deconstruct(self):
+    def deconstruct(self) -> tuple[str, tuple[Any, ...], dict[str, Any]]:
         path = f"{self.__class__.__module__}.{self.__class__.__name__}"
         path = path.replace("plain.models.constraints", "plain.models")
-        kwargs = {"name": self.name}
+        kwargs: dict[str, Any] = {"name": self.name}
         if (
             self.violation_error_message is not None
             and self.violation_error_message != self.default_violation_error_message
@@ -60,15 +69,20 @@ class BaseConstraint:
             kwargs["violation_error_code"] = self.violation_error_code
         return (path, (), kwargs)
 
-    def clone(self):
+    def clone(self) -> BaseConstraint:
         _, args, kwargs = self.deconstruct()
         return self.__class__(*args, **kwargs)
 
 
 class CheckConstraint(BaseConstraint):
     def __init__(
-        self, *, check, name, violation_error_code=None, violation_error_message=None
-    ):
+        self,
+        *,
+        check: Q,
+        name: str,
+        violation_error_code: str | None = None,
+        violation_error_message: str | None = None,
+    ) -> None:
         self.check = check
         if not getattr(check, "conditional", False):
             raise TypeError(
@@ -80,25 +94,27 @@ class CheckConstraint(BaseConstraint):
             violation_error_message=violation_error_message,
         )
 
-    def _get_check_sql(self, model, schema_editor):
+    def _get_check_sql(self, model: Any, schema_editor: Any) -> str:
         query = Query(model=model, alias_cols=False)
         where = query.build_where(self.check)
         compiler = query.get_compiler()
         sql, params = where.as_sql(compiler, schema_editor.connection)
         return sql % tuple(schema_editor.quote_value(p) for p in params)
 
-    def constraint_sql(self, model, schema_editor):
+    def constraint_sql(self, model: Any, schema_editor: Any) -> str:
         check = self._get_check_sql(model, schema_editor)
         return schema_editor._check_sql(self.name, check)
 
-    def create_sql(self, model, schema_editor):
+    def create_sql(self, model: Any, schema_editor: Any) -> str:
         check = self._get_check_sql(model, schema_editor)
         return schema_editor._create_check_sql(model, self.name, check)
 
-    def remove_sql(self, model, schema_editor):
+    def remove_sql(self, model: Any, schema_editor: Any) -> str:
         return schema_editor._delete_check_sql(model, self.name)
 
-    def validate(self, model, instance, exclude=None):
+    def validate(
+        self, model: Any, instance: Any, exclude: set[str] | None = None
+    ) -> None:
         against = instance._get_field_value_map(meta=model._meta, exclude=exclude)
         try:
             if not Q(self.check).check(against):
@@ -108,7 +124,7 @@ class CheckConstraint(BaseConstraint):
         except FieldError:
             pass
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "<{}: check={} name={}{}{}>".format(
             self.__class__.__qualname__,
             self.check,
@@ -126,7 +142,7 @@ class CheckConstraint(BaseConstraint):
             ),
         )
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if isinstance(other, CheckConstraint):
             return (
                 self.name == other.name
@@ -136,7 +152,7 @@ class CheckConstraint(BaseConstraint):
             )
         return super().__eq__(other)
 
-    def deconstruct(self):
+    def deconstruct(self) -> tuple[str, tuple[Any, ...], dict[str, Any]]:
         path, args, kwargs = super().deconstruct()
         kwargs["check"] = self.check
         return path, args, kwargs
@@ -147,23 +163,23 @@ class Deferrable(Enum):
     IMMEDIATE = "immediate"
 
     # A similar format was proposed for Python 3.10.
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{self.__class__.__qualname__}.{self._name_}"
 
 
 class UniqueConstraint(BaseConstraint):
     def __init__(
         self,
-        *expressions,
-        fields=(),
-        name=None,
-        condition=None,
-        deferrable=None,
-        include=None,
-        opclasses=(),
-        violation_error_code=None,
-        violation_error_message=None,
-    ):
+        *expressions: Any,
+        fields: tuple[str, ...] | list[str] = (),
+        name: str | None = None,
+        condition: Q | None = None,
+        deferrable: Deferrable | None = None,
+        include: tuple[str, ...] | list[str] | None = None,
+        opclasses: tuple[str, ...] | list[str] = (),
+        violation_error_code: str | None = None,
+        violation_error_message: str | None = None,
+    ) -> None:
         if not name:
             raise ValueError("A unique constraint must be named.")
         if not expressions and not fields:
@@ -213,16 +229,16 @@ class UniqueConstraint(BaseConstraint):
             for expression in expressions
         )
         super().__init__(
-            name=name,
+            name=name,  # type: ignore[arg-type]
             violation_error_code=violation_error_code,
             violation_error_message=violation_error_message,
         )
 
     @property
-    def contains_expressions(self):
+    def contains_expressions(self) -> bool:
         return bool(self.expressions)
 
-    def _get_condition_sql(self, model, schema_editor):
+    def _get_condition_sql(self, model: Any, schema_editor: Any) -> str | None:
         if self.condition is None:
             return None
         query = Query(model=model, alias_cols=False)
@@ -231,7 +247,7 @@ class UniqueConstraint(BaseConstraint):
         sql, params = where.as_sql(compiler, schema_editor.connection)
         return sql % tuple(schema_editor.quote_value(p) for p in params)
 
-    def _get_index_expressions(self, model, schema_editor):
+    def _get_index_expressions(self, model: Any, schema_editor: Any) -> Any:
         if not self.expressions:
             return None
         index_expressions = []
@@ -243,7 +259,7 @@ class UniqueConstraint(BaseConstraint):
             Query(model, alias_cols=False),
         )
 
-    def constraint_sql(self, model, schema_editor):
+    def constraint_sql(self, model: Any, schema_editor: Any) -> str:
         fields = [model._meta.get_field(field_name) for field_name in self.fields]
         include = [
             model._meta.get_field(field_name).column for field_name in self.include
@@ -261,7 +277,7 @@ class UniqueConstraint(BaseConstraint):
             expressions=expressions,
         )
 
-    def create_sql(self, model, schema_editor):
+    def create_sql(self, model: Any, schema_editor: Any) -> str:
         fields = [model._meta.get_field(field_name) for field_name in self.fields]
         include = [
             model._meta.get_field(field_name).column for field_name in self.include
@@ -279,7 +295,7 @@ class UniqueConstraint(BaseConstraint):
             expressions=expressions,
         )
 
-    def remove_sql(self, model, schema_editor):
+    def remove_sql(self, model: Any, schema_editor: Any) -> str:
         condition = self._get_condition_sql(model, schema_editor)
         include = [
             model._meta.get_field(field_name).column for field_name in self.include
@@ -295,7 +311,7 @@ class UniqueConstraint(BaseConstraint):
             expressions=expressions,
         )
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "<{}:{}{}{}{}{}{}{}{}{}>".format(
             self.__class__.__qualname__,
             "" if not self.fields else f" fields={repr(self.fields)}",
@@ -318,7 +334,7 @@ class UniqueConstraint(BaseConstraint):
             ),
         )
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if isinstance(other, UniqueConstraint):
             return (
                 self.name == other.name
@@ -333,7 +349,7 @@ class UniqueConstraint(BaseConstraint):
             )
         return super().__eq__(other)
 
-    def deconstruct(self):
+    def deconstruct(self) -> tuple[str, tuple[Any, ...], dict[str, Any]]:
         path, args, kwargs = super().deconstruct()
         if self.fields:
             kwargs["fields"] = self.fields
@@ -347,7 +363,9 @@ class UniqueConstraint(BaseConstraint):
             kwargs["opclasses"] = self.opclasses
         return path, self.expressions, kwargs
 
-    def validate(self, model, instance, exclude=None):
+    def validate(
+        self, model: Any, instance: Any, exclude: set[str] | None = None
+    ) -> None:
         queryset = model.query
         if self.fields:
             lookup_kwargs = {}

plain/models/database_url.py

@@ -182,4 +182,4 @@ def build_database_url(config: dict) -> str:
 
     path = f"/{name}"
     url = urlparse.urlunsplit((scheme, netloc, path, query, ""))
-    return url
+    return str(url)

plain/models/db.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from typing import Any
+
 from plain import signals
 
 from .connections import DatabaseConnection
@@ -22,7 +26,7 @@ db_connection = DatabaseConnection()
 
 
 # Register an event to reset saved queries when a Plain request is started.
-def reset_queries(**kwargs):
+def reset_queries(**kwargs: Any) -> None:
     if db_connection.has_connection():
         db_connection.queries_log.clear()
 
@@ -32,7 +36,7 @@ signals.request_started.connect(reset_queries)
 
 # Register an event to reset transaction state and close connections past
 # their lifetime.
-def close_old_connections(**kwargs):
+def close_old_connections(**kwargs: Any) -> None:
     if db_connection.has_connection():
         db_connection.close_if_unusable_or_obsolete()
 

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,
@@ -11,23 +15,26 @@ from plain.models import (
 from plain.models.db import IntegrityError, db_connection
 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,54 +42,54 @@ 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(opts: Any) -> 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 (
@@ -93,26 +100,38 @@ def get_candidate_relations_to_delete(opts):
 
 
 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 +155,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 +195,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
@@ -205,7 +226,7 @@ class Collector:
             )
         )
 
-    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 +245,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
@@ -342,7 +363,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.
         """
@@ -352,7 +375,7 @@ class Collector:
         )
         return related_model._meta.base_queryset.filter(predicate)
 
-    def sort(self):
+    def sort(self) -> None:
         sorted_models = []
         concrete_models = set()
         models = list(self.data)
@@ -370,7 +393,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"))

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