plain.postgres 0.94.1__tar.gz → 0.94.2__tar.gz

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/.gitignore

@@ -18,6 +18,7 @@ plain*/tests/.plain
 
 .vscode
 /.claude/settings.local.json
+/.claude/skills/announcements/
 /CLAUDE.local.md
 /.benchmarks
 .claude/worktrees

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: plain.postgres
-Version: 0.94.1
+Version: 0.94.2
 Summary: Model your data and store it in a database.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-Expression: BSD-3-Clause
 License-File: LICENSE
 Requires-Python: >=3.13
-Requires-Dist: plain<1.0.0,>=0.129.0
+Requires-Dist: plain<1.0.0,>=0.132.0
 Requires-Dist: sqlparse>=0.3.1
 Description-Content-Type: text/markdown
 

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,16 @@
 # plain-postgres changelog
 
+## [0.94.2](https://github.com/dropseed/plain/releases/plain-postgres@0.94.2) (2026-04-13)
+
+### What's changed
+
+- Updated internal references to use the fixed `app.users.models.User` convention. ([0861c9915cb6](https://github.com/dropseed/plain/commit/0861c9915cb6))
+- Migrated type suppression comments to `ty: ignore` for the new ty checker version. ([4ec631a7ef51](https://github.com/dropseed/plain/commit/4ec631a7ef51))
+
+### Upgrade instructions
+
+- No changes required.
+
 ## [0.94.1](https://github.com/dropseed/plain/releases/plain-postgres@0.94.1) (2026-04-05)
 
 ### What's changed

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/agents/.claude/skills/plain-postgres-doctor/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: plain-postgres-doctor
 description: Check overall database health — schema correctness and operational health. Use when asked to check the database, validate schema, optimize indexes, or diagnose Postgres problems.
+context: fork
 ---
 
 # Database Doctor

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/aggregates.py

@@ -75,7 +75,7 @@ class Aggregate(Func):
         self.filter = self.filter and exprs_list.pop()
         super().set_source_expressions(exprs_list)
 
-    def resolve_expression(  # type: ignore[override]
+    def resolve_expression(  # ty: ignore[invalid-method-override]
         self,
         query: Any = None,
         allow_joins: bool = True,
@@ -140,7 +140,7 @@ class Aggregate(Func):
         if self.filter is not None:
             # Use FILTER clause for aggregates when filter is specified
             try:
-                filter_sql, filter_params = self.filter.as_sql(compiler, connection)  # type: ignore[union-attr]
+                filter_sql, filter_params = self.filter.as_sql(compiler, connection)  # ty: ignore[unresolved-attribute]
             except FullResultSet:
                 pass
             else:

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/base.py

@@ -744,7 +744,7 @@ class Model(metaclass=ModelBase):
 
         if len(unique_check) == 1:
             field = meta.get_forward_field(unique_check[0])
-            params["field_label"] = field.name  # type: ignore[assignment]
+            params["field_label"] = field.name  # ty: ignore[invalid-assignment]
             return ValidationError(
                 message=field.error_messages["unique"],
                 code="unique",
@@ -1215,7 +1215,7 @@ class Model(metaclass=ModelBase):
             fld = None
             for part in field.split(LOOKUP_SEP):
                 try:
-                    fld = _cls._model_meta.get_field(part)  # type: ignore[unresolved-attribute]
+                    fld = _cls._model_meta.get_field(part)  # ty: ignore[unresolved-attribute]
                     if isinstance(fld, RelatedField):
                         _cls = fld.path_infos[-1].to_meta.model
                     else:
@@ -1413,4 +1413,4 @@ def model_unpickle(model_id: tuple[str, str] | type[Model]) -> Model:
 
 
 # Pickle protocol marker - functions don't normally have this attribute
-model_unpickle.__safe_for_unpickle__ = True  # type: ignore[attr-defined]
+model_unpickle.__safe_for_unpickle__ = True  # ty: ignore[unresolved-attribute]

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/cli/migrations.py

@@ -16,7 +16,7 @@ from ..db import get_connection
 from ..migrations.autodetector import MigrationAutodetector
 from ..migrations.executor import MigrationExecutor
 from ..migrations.loader import AmbiguityError, MigrationLoader
-from ..migrations.migration import Migration, SettingsTuple
+from ..migrations.migration import Migration
 from ..migrations.optimizer import MigrationOptimizer
 from ..migrations.questioner import (
     InteractiveMigrationQuestioner,
@@ -971,9 +971,7 @@ def squash(
             )
         operations.extend(smigration.operations)
         for dependency in smigration.dependencies:
-            if isinstance(dependency, SettingsTuple):
-                dependencies.add(dependency)
-            elif dependency[0] != smigration.package_label or first_migration:
+            if dependency[0] != smigration.package_label or first_migration:
                 dependencies.add(dependency)
         first_migration = False
 

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/connection.py

@@ -354,7 +354,7 @@ class DatabaseConnection:
             return False
         if new_role := self.settings_dict.get("OPTIONS", {}).get("assume_role"):
             sql_str = self.compose_sql("SET ROLE %s", [new_role])
-            self.connection.execute(sql_str)  # type: ignore[arg-type]
+            self.connection.execute(sql_str)  # ty: ignore[invalid-argument-type]
             return True
         return False
 
@@ -373,7 +373,7 @@ class DatabaseConnection:
 
         # Register the cursor timezone only if the connection disagrees, to avoid copying the adapter map.
         tzloader = self.connection.adapters.get_loader(TIMESTAMPTZ_OID, Format.TEXT)
-        if self.timezone != tzloader.timezone:  # type: ignore[union-attr]
+        if self.timezone != tzloader.timezone:  # ty: ignore[unresolved-attribute]
             register_tzloader(self.timezone, cursor)
         return cursor
 
@@ -1309,7 +1309,7 @@ class CursorMixin:
 
         qparts.append(psycopg_sql.SQL(")"))
         stmt = psycopg_sql.Composed(qparts)
-        self.execute(stmt)  # type: ignore[attr-defined]
+        self.execute(stmt)  # ty: ignore[unresolved-attribute]
         return args
 
 

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/constraints.py

@@ -372,7 +372,7 @@ class UniqueConstraint(BaseConstraint):
             if exclude:
                 for expression in self.expressions:
                     if hasattr(expression, "flatten"):
-                        for expr in expression.flatten():  # type: ignore[operator]
+                        for expr in expression.flatten():  # ty: ignore[call-non-callable]
                             if isinstance(expr, F) and expr.name in exclude:
                                 return
                     elif isinstance(expression, F) and expression.name in exclude:

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/deletion.py

@@ -160,7 +160,7 @@ class Collector:
         if not objs:
             return []
         new_objs = []
-        model = objs[0].__class__  # type: ignore[index]
+        model = objs[0].__class__  # ty: ignore[not-subscriptable]
         instances = self.data[model]
         for obj in objs:
             if obj not in instances:
@@ -192,7 +192,7 @@ class Collector:
 
     def add_restricted_objects(self, field: RelatedField, objs: Iterable[Any]) -> None:
         if objs:
-            model = objs[0].__class__  # type: ignore[index]
+            model = objs[0].__class__  # ty: ignore[not-subscriptable]
             self.restricted_objects[model][field].update(objs)
 
     def clear_restricted_objects_from_set(self, model: Any, objs: set[Any]) -> None:

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/enums.py

@@ -35,26 +35,26 @@ 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)  # type: ignore[misc]
+        cls = super().__new__(metacls, classname, bases, classdict, **kwds)  # ty: ignore[invalid-super-argument]
         for member, label in zip(cls.__members__.values(), labels):
             member._label_ = label
         return enum.unique(cls)
 
-    def __contains__(cls, member: object) -> bool:  # type: ignore[override]
+    def __contains__(cls, member: object) -> bool:  # ty: ignore[invalid-method-override]
         if not isinstance(member, enum.Enum):
             # Allow non-enums to match against member values.
-            return any(x.value == member for x in cls)  # type: ignore[attr-defined]
+            return any(x.value == member for x in cls)  # ty: ignore[unresolved-attribute]
         return super().__contains__(member)
 
     @property
     def names(cls) -> list[str]:
         empty = ["__empty__"] if hasattr(cls, "__empty__") else []
-        return empty + [member.name for member in cls]  # type: ignore[attr-defined]
+        return empty + [member.name for member in cls]  # ty: ignore[unresolved-attribute]
 
     @property
     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]  # type: ignore[attr-defined]
+        return empty + [(member.value, member.label) for member in cls]  # ty: ignore[unresolved-attribute, invalid-return-type]
 
     @property
     def labels(cls) -> list[str]:

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/expressions.py

@@ -432,7 +432,7 @@ class BaseExpression:
         return self.output_field.get_lookup(lookup)
 
     def get_transform(self, name: str) -> type[Transform] | None:
-        return self.output_field.get_transform(name)  # type: ignore[return-type]
+        return self.output_field.get_transform(name)  # ty: ignore[invalid-return-type]
 
     def relabeled_clone(self, change_map: dict[str, str]) -> Self:
         clone = self.copy()
@@ -1045,7 +1045,7 @@ class Value(Expression):
             else:
                 val = output_field.get_db_prep_value(val, connection=connection)
             if hasattr(output_field, "get_placeholder"):
-                return output_field.get_placeholder(val, compiler, connection), [val]  # type: ignore[call-non-callable]
+                return output_field.get_placeholder(val, compiler, connection), [val]  # ty: ignore[call-non-callable]
         if val is None:
             return "NULL", []
         return "%s", [val]
@@ -1366,7 +1366,7 @@ class When(Expression):
         if isinstance(condition, Q) and not condition:
             raise ValueError("An empty Q() can't be used as a When() condition.")
         super().__init__(output_field=None)
-        self.condition = condition  # type: ignore[assignment]
+        self.condition = condition  # ty: ignore[invalid-assignment]
         self.result = self._parse_expressions(then)[0]
 
     def __str__(self) -> str:
@@ -1703,10 +1703,10 @@ class OrderBy(Expression):
             self.nulls_last = None
         return self
 
-    def asc(self) -> None:  # type: ignore[override]
+    def asc(self) -> None:  # ty: ignore[invalid-method-override]
         self.descending = False
 
-    def desc(self) -> None:  # type: ignore[override]
+    def desc(self) -> None:  # ty: ignore[invalid-method-override]
         self.descending = True
 
 

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/fields/encrypted.py

@@ -10,11 +10,11 @@ try:
     from cryptography.hazmat.primitives import hashes
     from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
 except ImportError:
-    Fernet = None  # type: ignore[assignment,misc]
-    InvalidToken = None  # type: ignore[assignment,misc]
-    MultiFernet = None  # type: ignore[assignment,misc]
-    hashes = None  # type: ignore[assignment]
-    PBKDF2HMAC = None  # type: ignore[assignment]
+    Fernet = None  # ty: ignore[invalid-assignment]
+    InvalidToken = None  # ty: ignore[invalid-assignment]
+    MultiFernet = None  # ty: ignore[invalid-assignment]
+    hashes = None  # ty: ignore[invalid-assignment]
+    PBKDF2HMAC = None  # ty: ignore[invalid-assignment]
 
 from plain import exceptions, preflight
 from plain.runtime import settings

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/fields/related.py

@@ -11,7 +11,6 @@ from plain.postgres.exceptions import FieldDoesNotExist, FieldError
 from plain.postgres.query_utils import PathInfo, Q
 from plain.postgres.utils import make_model_tuple
 from plain.preflight import PreflightResult
-from plain.runtime import SettingsReference
 
 from ..registry import models_registry
 from . import Field
@@ -115,7 +114,7 @@ class RelatedField(FieldCacheMixin, Field):
         obj = super().__deepcopy__(memodict)
         obj.remote_field = copy.copy(self.remote_field)
         if hasattr(self.remote_field, "field") and self.remote_field.field is self:
-            obj.remote_field.field = obj  # type: ignore[misc]
+            obj.remote_field.field = obj  # ty: ignore[invalid-assignment]
         return obj
 
     @cached_property
@@ -288,7 +287,7 @@ class RelatedField(FieldCacheMixin, Field):
         returned.
         """
         if callable(self.remote_field.limit_choices_to):
-            return self.remote_field.limit_choices_to()  # type: ignore[call-top-callable]
+            return self.remote_field.limit_choices_to()  # ty: ignore[call-top-callable]
         return self.remote_field.limit_choices_to
 
     def related_query_name(self) -> str:
@@ -543,9 +542,7 @@ class ForeignKeyField(RelatedField):
         name, path, args, kwargs = super().deconstruct()
         kwargs["on_delete"] = self.remote_field.on_delete
 
-        if isinstance(self.remote_field.model, SettingsReference):
-            kwargs["to"] = self.remote_field.model
-        elif isinstance(self.remote_field.model, str):
+        if isinstance(self.remote_field.model, str):
             if "." in self.remote_field.model:
                 package_label, model_name = self.remote_field.model.split(".")
                 kwargs["to"] = f"{package_label}.{model_name.lower()}"
@@ -1130,7 +1127,7 @@ class ManyToManyField(RelatedField):
         )
 
         # Add the descriptor for the m2m relation.
-        setattr(cls, self.name, ForwardManyToManyDescriptor(self.remote_field))  # type: ignore[arg-type]
+        setattr(cls, self.name, ForwardManyToManyDescriptor(self.remote_field))  # ty: ignore[invalid-argument-type]
 
         # Set up the accessor for the m2m table name for the relation.
         self.m2m_db_table = self._get_m2m_db_table

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/fields/related_managers.py

@@ -367,7 +367,7 @@ class ManyToManyManager(BaseRelatedManager[T, QS]):
         for lh_field, rh_field in self.source_field.related_fields:
             core_filter_key = f"{self.query_field_name}__{rh_field.name}"
             self.core_filters[core_filter_key] = getattr(instance, rh_field.attname)
-            self.id_field_names[lh_field.name] = rh_field.name  # type: ignore[assignment]
+            self.id_field_names[lh_field.name] = rh_field.name  # ty: ignore[invalid-assignment]
 
         self.related_val = self.source_field.get_foreign_related_value(instance)
         if None in self.related_val:

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/fields/reverse_related.py

@@ -69,10 +69,10 @@ class ForeignObjectRel(FieldCacheMixin):
         limit_choices_to: dict[str, Any] | Q | None = None,
         on_delete: OnDeleteCallback | None = None,
     ):
-        self.field = field  # type: ignore[misc]
+        self.field = field  # ty: ignore[invalid-assignment]
         # Initially may be a string, gets resolved to type[Model] by lazy_related_operation
         # (see related.py:250 where field.remote_field.model is overwritten)
-        self.model = to  # type: ignore[assignment]
+        self.model = to  # ty: ignore[invalid-assignment]
         self.related_query_name = related_query_name
         self.limit_choices_to = {} if limit_choices_to is None else limit_choices_to
         self.on_delete = on_delete
@@ -290,7 +290,7 @@ class ManyToManyRel(ForeignObjectRel):
 
         # Initially may be a string, gets resolved to type[Model] by lazy_related_operation
         # (see related.py:1143 where field.remote_field.through is overwritten)
-        self.through = through  # type: ignore[assignment]
+        self.through = through  # ty: ignore[invalid-assignment]
         self.through_fields = through_fields
 
         self.symmetrical = symmetrical

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/forms.py

@@ -578,7 +578,7 @@ class ModelMultipleChoiceField(ModelChoiceField):
     def __init__(self, queryset: Any, **kwargs: Any) -> None:
         super().__init__(queryset, empty_label=None, **kwargs)
 
-    def to_python(self, value: Any) -> list[Any]:  # type: ignore[override]
+    def to_python(self, value: Any) -> list[Any]:  # ty: ignore[invalid-method-override]
         if not value:
             return []
         return list(self._check_values(value))

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/indexes.py

@@ -74,7 +74,7 @@ class Index:
         self.opclasses: tuple[str, ...] = tuple(opclasses)
         self.condition = condition
         self.include = tuple(include) if include else ()
-        self.expressions: tuple[Expression, ...] = tuple(  # type: ignore[assignment]
+        self.expressions: tuple[Expression, ...] = tuple(  # ty: ignore[invalid-assignment]
             F(expression) if isinstance(expression, str) else expression
             for expression in expressions
         )

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/lookups.py

@@ -441,7 +441,7 @@ class IntegerFieldOverflow:
                 raise self.underflow_exception
             if max_value is not None and rhs > max_value:
                 raise self.overflow_exception
-        return super().process_rhs(compiler, connection)  # type: ignore[misc]
+        return super().process_rhs(compiler, connection)  # ty: ignore[unresolved-attribute]
 
 
 class IntegerFieldFloatRounding:
@@ -455,7 +455,7 @@ class IntegerFieldFloatRounding:
     def get_prep_lookup(self) -> Any:
         if isinstance(self.rhs, float):
             self.rhs = math.ceil(self.rhs)
-        return super().get_prep_lookup()  # type: ignore[misc]
+        return super().get_prep_lookup()  # ty: ignore[unresolved-attribute]
 
 
 @IntegerField.register_lookup

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/meta.py

@@ -367,7 +367,7 @@ class Meta:
             )
 
         try:
-            return self.fields_map[field_name]  # type: ignore[return-type]
+            return self.fields_map[field_name]  # ty: ignore[invalid-return-type]
         except KeyError:
             raise FieldDoesNotExist(
                 f"{self.model} has no reverse relation named '{field_name}'"

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/migrations/__init__.py

@@ -1,5 +1,5 @@
 from ..schema import DatabaseSchemaEditor
-from .migration import Migration, settings_dependency
+from .migration import Migration
 from .operations import (
     AddField,
     AlterField,
@@ -19,7 +19,6 @@ from .state import StateModelsRegistry
 __all__ = [
     # Migration class
     "Migration",
-    "settings_dependency",
     # Model operations
     "CreateModel",
     "DeleteModel",

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/migrations/autodetector.py

@@ -15,7 +15,7 @@ from plain.postgres.fields import (
 from plain.postgres.fields.related import ManyToManyField, RelatedField
 from plain.postgres.fields.reverse_related import ManyToManyRel
 from plain.postgres.migrations import operations
-from plain.postgres.migrations.migration import Migration, SettingsTuple
+from plain.postgres.migrations.migration import Migration
 from plain.postgres.migrations.operations.models import AlterModelOptions
 from plain.postgres.migrations.optimizer import MigrationOptimizer
 from plain.postgres.migrations.questioner import MigrationQuestioner
@@ -24,7 +24,6 @@ from plain.postgres.migrations.utils import (
     RegexObject,
     resolve_relation,
 )
-from plain.runtime import settings
 
 if TYPE_CHECKING:
     from plain.postgres.migrations.graph import MigrationGraph
@@ -230,7 +229,7 @@ class MigrationAutodetector:
                     field.remote_field, "through", None
                 ):
                     through_key = resolve_relation(
-                        field.remote_field.through,  # type: ignore[unresolved-attribute]
+                        field.remote_field.through,  # ty: ignore[unresolved-attribute]
                         package_label,
                         model_name,
                     )
@@ -240,23 +239,6 @@ class MigrationAutodetector:
                         field_name,
                     )
 
-    @staticmethod
-    def _resolve_dependency(
-        dependency: tuple[str, str, str | None, bool | str],
-    ) -> tuple[tuple[str, str, str | None, bool | str], bool]:
-        """
-        Return the resolved dependency and a boolean denoting whether or not
-        it was a settings dependency.
-        """
-        if not isinstance(dependency, SettingsTuple):
-            return dependency, False
-        resolved_package_label, resolved_object_name = getattr(
-            settings, dependency[1]
-        ).split(".")
-        return (resolved_package_label, resolved_object_name.lower()) + dependency[
-            2:
-        ], True
-
     def _build_migration_list(self, graph: MigrationGraph | None = None) -> None:
         """
         Chop the lists of operations up into migrations with dependencies on
@@ -285,12 +267,6 @@ class MigrationAutodetector:
                     deps_satisfied = True
                     operation_dependencies = set()
                     for dep in operation._auto_deps:
-                        # Temporarily resolve the settings dependency to
-                        # prevent circular references. While keeping the
-                        # dependency checks on the resolved model, add the
-                        # settings dependencies.
-                        original_dep = dep
-                        dep, is_settings_dep = self._resolve_dependency(dep)
                         if dep[0] != package_label:
                             # External app dependency. See if it's not yet
                             # satisfied.
@@ -303,11 +279,7 @@ class MigrationAutodetector:
                             if not deps_satisfied:
                                 break
                             else:
-                                if is_settings_dep:
-                                    operation_dependencies.add(
-                                        (original_dep[0], original_dep[1])
-                                    )
-                                elif dep[0] in self.migrations:
+                                if dep[0] in self.migrations:
                                     operation_dependencies.add(
                                         (dep[0], self.migrations[dep[0]][-1].name)
                                     )
@@ -381,9 +353,6 @@ class MigrationAutodetector:
             for op in ops:
                 ts.add(op)
                 for dep in op._auto_deps:
-                    # Resolve intra-app dependencies to handle circular
-                    # references involving a settings model.
-                    dep = self._resolve_dependency(dep)[0]
                     if dep[0] != package_label:
                         continue
                     ts.add(op, *(x for x in ops if self.check_dependency(x, dep)))
@@ -894,19 +863,19 @@ class MigrationAutodetector:
                 new_field.remote_field, "model", None
             ):
                 rename_key = resolve_relation(
-                    new_field.remote_field.model,  # type: ignore[unresolved-attribute]
+                    new_field.remote_field.model,  # ty: ignore[unresolved-attribute]
                     package_label,
                     model_name,
                 )
                 if rename_key in self.renamed_models:
-                    new_field.remote_field.model = old_field.remote_field.model  # type: ignore[unresolved-attribute]
+                    new_field.remote_field.model = old_field.remote_field.model  # ty: ignore[unresolved-attribute]
                 # Handle ForeignKeyField which can only have a single to_field.
                 remote_field_name = getattr(new_field.remote_field, "field_name", None)
                 if remote_field_name:
                     to_field_rename_key = rename_key + (remote_field_name,)
                     if to_field_rename_key in self.renamed_fields:
                         # Repoint model name only
-                        new_field.remote_field.model = old_field.remote_field.model  # type: ignore[unresolved-attribute]
+                        new_field.remote_field.model = old_field.remote_field.model  # ty: ignore[unresolved-attribute]
                 dependencies.extend(
                     self._get_dependencies_for_foreign_key(
                         package_label,
@@ -919,12 +888,12 @@ class MigrationAutodetector:
                 new_field.remote_field, "through", None
             ):
                 rename_key = resolve_relation(
-                    new_field.remote_field.through,  # type: ignore[unresolved-attribute]
+                    new_field.remote_field.through,  # ty: ignore[unresolved-attribute]
                     package_label,
                     model_name,
                 )
                 if rename_key in self.renamed_models:
-                    new_field.remote_field.through = old_field.remote_field.through  # type: ignore[unresolved-attribute]
+                    new_field.remote_field.through = old_field.remote_field.through  # ty: ignore[unresolved-attribute]
             old_field_dec = self.deep_deconstruct(old_field)
             new_field_dec = self.deep_deconstruct(new_field)
             if old_field_dec != new_field_dec and old_field_name == field_name:

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/migrations/graph.py

@@ -357,7 +357,7 @@ class MigrationGraph:
         plan = self._generate_plan(nodes, at_end)
         project_state = ProjectState(real_packages=real_packages)
         for node in plan:
-            project_state = self.nodes[node].mutate_state(project_state, preserve=False)  # type: ignore[attr-defined]
+            project_state = self.nodes[node].mutate_state(project_state, preserve=False)  # ty: ignore[unresolved-attribute]
         return project_state
 
     def __contains__(self, node: tuple[str, str]) -> bool:

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/migrations/migration.py

@@ -161,20 +161,3 @@ class Migration:
                 break
             name = new_name
         return name
-
-
-class SettingsTuple(tuple):
-    """
-    Subclass of tuple so Plain can tell this was originally a settings
-    dependency when it reads the migration file.
-    """
-
-    def __new__(cls, value: tuple[str, str], setting: str) -> SettingsTuple:
-        self = tuple.__new__(cls, value)
-        self.setting = setting
-        return self
-
-
-def settings_dependency(value: str) -> SettingsTuple:
-    """Turn a setting value into a dependency."""
-    return SettingsTuple((value.split(".", 1)[0], "__first__"), value)

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/migrations/recorder.py

@@ -33,7 +33,7 @@ class MigrationRecorder:
 
     _migration_class: type[postgres.Model] | None = None
 
-    @classproperty  # type: ignore[invalid-argument-type]
+    @classproperty  # ty: ignore[invalid-argument-type]
     def Migration(cls) -> type[postgres.Model]:
         """
         Lazy load to avoid PackageRegistryNotReady if installed packages import

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/migrations/serializer.py

@@ -19,7 +19,6 @@ from plain.postgres.enums import Choices
 from plain.postgres.fields import Field
 from plain.postgres.migrations.operations.base import Operation
 from plain.postgres.migrations.utils import COMPILED_REGEX_TYPE, RegexObject
-from plain.runtime import SettingsReference
 from plain.utils.functional import LazyObject, Promise
 
 
@@ -277,13 +276,6 @@ class SetSerializer(BaseSequenceSerializer):
         return "{%s}" if self.value else "set(%s)"
 
 
-class SettingsReferenceSerializer(BaseSerializer):
-    def serialize(self) -> tuple[str, set[str]]:
-        return f"settings.{self.value.setting_name}", {
-            "from plain.runtime import settings"
-        }
-
-
 class TupleSerializer(BaseSequenceSerializer):
     def _format(self) -> str:
         # When len(value)==0, the empty tuple should be serialized as "()",
@@ -326,7 +318,6 @@ class Serializer:
         enum.Enum: EnumSerializer,
         datetime.datetime: DatetimeDatetimeSerializer,
         (datetime.date, datetime.timedelta, datetime.time): DateTimeSerializer,
-        SettingsReference: SettingsReferenceSerializer,
         float: FloatSerializer,
         (bool, int, types.NoneType, bytes, str, range): BaseSimpleSerializer,
         decimal.Decimal: DecimalSerializer,
@@ -349,7 +340,7 @@ class Serializer:
             raise ValueError(
                 f"'{serializer.__name__}' must inherit from 'BaseSerializer'."
             )
-        cls._registry[type_] = serializer  # type: ignore[assignment]
+        cls._registry[type_] = serializer  # ty: ignore[invalid-assignment]
 
 
 def serializer_factory(value: Any) -> BaseSerializer:

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/migrations/state.py

@@ -170,12 +170,12 @@ class ProjectState:
             if reference.to:
                 changed_field = field.clone()
                 assert changed_field.remote_field is not None
-                changed_field.remote_field.model = new_remote_model  # type: ignore[assignment]
+                changed_field.remote_field.model = new_remote_model  # ty: ignore[invalid-assignment]
             if reference.through:
                 if changed_field is None:
                     changed_field = field.clone()
                 assert changed_field.remote_field is not None
-                changed_field.remote_field.through = new_remote_model  # type: ignore[attr-defined]
+                changed_field.remote_field.through = new_remote_model  # ty: ignore[unresolved-attribute]
             if changed_field:
                 model_state.fields[name] = changed_field
                 to_reload.add((model_state.package_label, model_state.name_lower))

{plain_postgres-0.94.1 → plain_postgres-0.94.2}/plain/postgres/migrations/utils.py

@@ -137,7 +137,7 @@ def get_references(
                 *field_tuple,
             )
             if reference:
-                yield model_state, name, field, reference
+                yield model_state, name, field, reference  # ty: ignore[invalid-yield]
 
 
 def field_is_referenced(