Upgrade ruff to 0.16.4 and ty to 0.0.74 (#103)

Co-authored-by: Claude <noreply@anthropic.com>

Author: davegaeddert

plain-admin/plain/admin/cards/base.py

@@ -102,6 +102,6 @@ def get_current_filter(self) -> str:
     def get_filters(self) -> list[str] | Enum | None:
         if isinstance(self.filters, list):
             # Avoid mutating the class attribute
-            return self.filters.copy()  # type: ignore
+            return self.filters.copy()
         else:
             return self.filters

plain-admin/plain/admin/views/viewsets.py

@@ -27,7 +27,7 @@ def get_views(cls) -> list[type[View]]:
             DeleteView.parent_view_class = DetailView
 
         # Now iterate all inner view classes
-        views = []
+        views: list[type[View]] = []
 
         for attr in cls.__dict__.values():
             if isinstance(attr, type) and issubclass(attr, View):

plain-auth/plain/auth/test.py

@@ -26,16 +26,23 @@ def login_client(client: Client, user: Any) -> None:
     login(request, user)
     session = get_request_session(request)
     session.save()
+    assert session.session_key is not None
     session_cookie = settings.SESSION_COOKIE_NAME
     client.cookies[session_cookie] = session.session_key
-    cookie_data = {
+    cookie_data: dict[str, Any] = {
         "max-age": None,
         "path": "/",
         "domain": settings.SESSION_COOKIE_DOMAIN,
         "secure": settings.SESSION_COOKIE_SECURE or None,
         "expires": None,
     }
-    client.cookies[session_cookie].update(cookie_data)
+    # Morsel.update() is typed for str-only values, but these cookie
+    # attributes are legitimately None (unset). Set them one at a time
+    # through __setitem__, which is typed for Any and keeps Morsel's own
+    # reserved-key validation (unlike bypassing update() with dict.update()).
+    morsel = client.cookies[session_cookie]
+    for key, value in cookie_data.items():
+        morsel[key] = value
 
 
 def logout_client(client: Client) -> None:

plain-passwords/plain/passwords/models.py

@@ -24,7 +24,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
         )
         super().__init__(*args, **kwargs)
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         name, path, args, kwargs = super().deconstruct()
         if kwargs.get("max_length") == 128:
             del kwargs["max_length"]
@@ -36,7 +36,6 @@ def pre_save(self, model_instance: postgres.Model, add: bool) -> str | None:
         if value and not self._is_hashed(value):
             value = hash_password(value)
             # Set the hashed value back on the instance immediately too
-            assert self.name is not None
             setattr(model_instance, self.name, value)
 
         return value

plain-postgres/plain/postgres/base.py

@@ -494,7 +494,6 @@ def _insert_row(self) -> None:
         )
         if results:
             for value, field in zip(results[0], returning_fields):
-                assert field.name is not None
                 setattr(self, field.name, value)
 
     def _update_row(self, fields: Iterable[str] | None) -> None:
@@ -578,7 +577,6 @@ def delete(self) -> int:
         with transaction.mark_for_rollback_on_error():
             count = self._model_meta.base_queryset.filter(id=self.id)._raw_delete()
         id_field = self._model_meta.get_forward_field("id")
-        assert id_field.name is not None
         setattr(self, id_field.name, None)
         # Only the id is cleared -- every other field value survives so callers
         # can still reference a deleted row (correlate it, log it, check it's
@@ -707,6 +705,8 @@ def clean_fields(self, exclude: set[str] | None = None) -> None:
 
         errors = {}
         for f in self._model_meta.fields:
+            # See __init__ above: meta.fields is always ColumnField.
+            assert isinstance(f, ColumnField)
             if f.name in exclude:
                 continue
             # Skip validation for empty fields with required=False. The developer
@@ -1089,9 +1089,9 @@ def _check_ordering(cls) -> list[PreflightResult]:
         meta = cls._model_meta
         valid_fields = set(
             chain.from_iterable(
-                (f.name,)
-                if not (f.auto_created and not f.concrete)
-                else (f.field.related_query_name(),)
+                (f.field.related_query_name(),)
+                if isinstance(f, ForeignObjectRel)
+                else (f.name,)
                 for f in chain(meta.fields, meta.related_objects)
             )
         )

plain-postgres/plain/postgres/constraints.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from types import NoneType
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 from plain.exceptions import ValidationError
 from plain.postgres.constants import LOOKUP_SEP
@@ -454,7 +454,7 @@ def _unique_error_message(
         field_names[-1] = f"and {field_names[-1]}"
         # Comma-join when more than two, otherwise just space-join.
         sep = ", " if len(field_names) > 2 else " "
-        params["field_label"] = sep.join(cast(list[str], field_names))
+        params["field_label"] = sep.join(field_names)
 
         # Use the first field's message format.
         message = meta.get_forward_field(unique_check[0]).unique_error_message

plain-postgres/plain/postgres/convergence/analysis.py

@@ -635,8 +635,6 @@ def _compare_columns(
         if f.primary_key:
             pk_suffix = f.db_type_suffix() or ""
 
-        # Fields reached via local_fields are always contributed (name set).
-        assert f.name is not None
         statuses.append(
             ColumnStatus(
                 name=f.column,

plain-postgres/plain/postgres/fields/base.py

@@ -110,8 +110,9 @@ class Field[T](RegisterLookupMixin):
     cast_db_type_sql: str | None = None
 
     # Instance attributes set during field lifecycle
-    # Set by __init__
-    name: str | None
+    # Set by __init__; becomes the real field name once contributed to a
+    # model class (set_attributes_from_name, called by contribute_to_class)
+    name: str
     # Set by set_attributes_from_name (called by contribute_to_class)
     column: str
     concrete: bool
@@ -134,7 +135,7 @@ class Field[T](RegisterLookupMixin):
     non_migration_attrs: tuple[str, ...] = ()
 
     def __init__(self) -> None:
-        self.name = None  # Set by set_attributes_from_name
+        self.name = ""  # Set by set_attributes_from_name
         self.primary_key = False
         self.auto_created = False
 
@@ -151,8 +152,8 @@ def __str__(self) -> str:
     def __repr__(self) -> str:
         """Display the module, class, and name of the field."""
         path = f"{self.__class__.__module__}.{self.__class__.__qualname__}"
-        name = getattr(self, "name", None)
-        if name is not None:
+        name = getattr(self, "name", "")
+        if name:
             return f"<{path}: {name}>"
         return f"<{path}>"
 
@@ -164,7 +165,6 @@ def _check_field_name(self) -> list[PreflightResult]:
         Check if field name is valid, i.e. 1) does not end with an
         underscore, 2) does not contain "__" and 3) is not "id".
         """
-        assert self.name is not None, "Field name must be set before checking"
         if self.name.endswith("_"):
             return [
                 PreflightResult(
@@ -215,7 +215,7 @@ def select_format(
         """
         return sql, params
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         """
         Return enough information to recreate the field as a 4-tuple:
 
@@ -259,7 +259,6 @@ def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
             cls_name = self.__class__.__qualname__
             if getattr(_postgres_root, cls_name, None) is self.__class__:
                 path = f"plain.postgres.{cls_name}"
-        # Note: self.name can be None during migration state rendering when fields are cloned
         return (self.name, path, [], keywords)
 
     def clone(self) -> Self:
@@ -305,7 +304,6 @@ def __reduce__(
             # values - so, this is very close to normal pickle.
             state = self.__dict__.copy()
             return _empty, (self.__class__,), state
-        assert self.name is not None
         options = model.model_options
         return _load_field, (
             options.package_label,
@@ -394,7 +392,6 @@ def contribute_to_class(self, cls: type[Model], name: str) -> None:
         # Field is its own descriptor; make sure it is set on the class so
         # attribute access hits __get__/__set__.
         if self.column:
-            assert self.name is not None
             setattr(cls, self.name, self)
 
     # Descriptor protocol implementation
@@ -422,7 +419,6 @@ def __get__(self, instance: Model | None, owner: type[Model]) -> Self | T:
             return self
 
         # Instance access - get value from instance dict
-        assert self.name is not None
         data = instance.__dict__
         field_name = self.name
 
@@ -472,7 +468,6 @@ def __set__(self, instance: Model, value: T) -> None:
             stored = self.to_python(value)
 
         # Store in instance dict
-        assert self.name is not None
         instance.__dict__[self.name] = stored
 
     def __delete__(self, instance: Model) -> None:
@@ -481,7 +476,6 @@ def __delete__(self, instance: Model) -> None:
 
         Removes the value from instance.__dict__.
         """
-        assert self.name is not None
         try:
             del instance.__dict__[self.name]
         except KeyError:
@@ -491,7 +485,6 @@ def __delete__(self, instance: Model) -> None:
 
     def pre_save(self, model_instance: Model, add: bool) -> T | None:
         """Return field's value just before saving."""
-        assert self.name is not None
         return getattr(model_instance, self.name)
 
     def get_prep_value(self, value: Any) -> Any:
@@ -544,12 +537,10 @@ def has_db_default(self) -> bool:
         return self.get_db_default_expression() is not None
 
     def save_form_data(self, instance: Model, data: Any) -> None:
-        assert self.name is not None
         setattr(instance, self.name, data)
 
     def value_from_object(self, obj: Model) -> T | None:
         """Return the value of this field in the given model instance."""
-        assert self.name is not None
         return getattr(obj, self.name)
 
 
@@ -653,7 +644,7 @@ def get_default(self) -> Any:
             return None
         return self._default_empty_value
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         name, path, args, kwargs = super().deconstruct()
         if self.required is not True:
             kwargs["required"] = self.required
@@ -750,7 +741,7 @@ def get_default(self) -> Any:
         # shared state across instances.
         return copy.deepcopy(self.default)
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         name, path, args, kwargs = super().deconstruct()
         if self.default is not NOT_PROVIDED:
             kwargs["default"] = self.default
@@ -891,7 +882,7 @@ def validate(self, value: Any, model_instance: Model) -> None:
             )
         super().validate(value, model_instance)
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         name, path, args, kwargs = super().deconstruct()
         if self.choices is not None:
             choices = self.choices

plain-postgres/plain/postgres/fields/binary.py

@@ -41,7 +41,7 @@ def __init__(
         if self.max_length is not None:
             self.validators.append(MaxLengthValidator(self.max_length))
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         name, path, args, kwargs = super().deconstruct()
         if self.max_length is not None:
             kwargs["max_length"] = self.max_length

plain-postgres/plain/postgres/fields/encrypted.py

@@ -14,7 +14,7 @@
     InvalidToken = None  # ty: ignore[invalid-assignment]
     MultiFernet = None  # ty: ignore[invalid-assignment]
     hashes = None  # ty: ignore[invalid-assignment]
-    PBKDF2HMAC = None  # ty: ignore[invalid-assignment]
+    PBKDF2HMAC = None
 
 from plain.postgres.lookups import Exact, IsNull
 from plain.runtime import settings