plain.postgres 0.103.3__tar.gz → 0.103.4__tar.gz

{plain_postgres-0.103.3 → plain_postgres-0.103.4}/.gitignore

@@ -3,6 +3,7 @@
 *.egg-info
 *.py[co]
 __pycache__
+.pytest_cache
 *.DS_Store
 *.swp
 *.swo

{plain_postgres-0.103.3 → plain_postgres-0.103.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.postgres
-Version: 0.103.3
+Version: 0.103.4
 Summary: Model your data and store it in a database.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-Expression: BSD-3-Clause

{plain_postgres-0.103.3 → plain_postgres-0.103.4}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,15 @@
 # plain-postgres changelog
 
+## [0.103.4](https://github.com/dropseed/plain/releases/plain-postgres@0.103.4) (2026-05-12)
+
+### What's changed
+
+- **`postgres.duplicate_indexes` preflight check now skips partial indexes** (those with a `condition=`). Previously a bare `Index(fields=[fk])` carried for FK coverage was flagged as redundant with a partial composite `Index(fields=[fk, ...], condition=Q(...))`, contradicting the `postgres.missing_fk_index` check. The two warnings are now mutually consistent — partials don't cover full-column lookups, so they can't shadow a single-column index. ([1e8a3f72db](https://github.com/dropseed/plain/commit/1e8a3f72db))
+
+### Upgrade instructions
+
+- No changes required. Apps that were silencing `postgres.duplicate_indexes` to work around the false positive can drop the silence.
+
 ## [0.103.3](https://github.com/dropseed/plain/releases/plain-postgres@0.103.3) (2026-05-08)
 
 ### What's changed

{plain_postgres-0.103.3 → plain_postgres-0.103.4}/plain/postgres/preflight.py

@@ -27,16 +27,23 @@ def _get_app_models() -> list[Any]:
 
 
 def _collect_model_indexes(model: Any) -> list[tuple[str, list[str], bool]]:
-    """Collect all index field-lists for a model as (name, fields, is_unique) tuples."""
+    """Collect (name, fields, is_unique) for non-partial indexes/constraints.
+
+    Partials are skipped for the same reason as in ``_fk_covered_field_names``.
+    """
     all_indexes: list[tuple[str, list[str], bool]] = []
 
     for index in model.model_options.indexes:
-        if index.fields:
+        if index.fields and not index.is_partial:
             fields = [f.lstrip("-") for f in index.fields]
             all_indexes.append((index.name, fields, False))
 
     for constraint in model.model_options.constraints:
-        if isinstance(constraint, UniqueConstraint) and constraint.fields:
+        if (
+            isinstance(constraint, UniqueConstraint)
+            and constraint.fields
+            and not constraint.is_partial
+        ):
             all_indexes.append((constraint.name, list(constraint.fields), True))
 
     return all_indexes

{plain_postgres-0.103.3 → plain_postgres-0.103.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.postgres"
-version = "0.103.3"
+version = "0.103.4"
 description = "Model your data and store it in a database."
 authors = [{ name = "Dave Gaeddert", email = "dave.gaeddert@dropseed.dev" }]
 readme = "README.md"
@@ -16,7 +16,7 @@ dependencies = ["plain>=0.134.0,<1.0.0", "psycopg>=3.2", "psycopg-pool>=3.2"]
 "plain.postgres" = "plain.postgres.test.pytest"
 
 [dependency-groups]
-dev = ["plain.pytest<1.0.0", "opentelemetry-sdk>=1.34.1"]
+dev = ["plain.pytest<1.0.0", "plain.templates>=0.1.0,<1.0.0", "opentelemetry-sdk>=1.34.1"]
 
 [tool.hatch.build.targets.wheel]
 packages = ["plain"]

{plain_postgres-0.103.3 → plain_postgres-0.103.4}/tests/app/examples/views.py

@@ -5,7 +5,7 @@ from typing import Any
 
 from plain.forms import BaseForm
 from plain.http import Response
-from plain.views import CreateView, UpdateView
+from plain.templates.views import CreateView, UpdateView
 
 from .forms import (
     ChildCascadeForm,

{plain_postgres-0.103.3 → plain_postgres-0.103.4}/tests/app/settings.py

@@ -1,6 +1,7 @@
 SECRET_KEY = "test"
 URLS_ROUTER = "app.urls.AppRouter"
 INSTALLED_PACKAGES = [
+    "plain.templates",
     "plain.postgres",
     "app.examples",
 ]

plain_postgres-0.103.4/tests/internal/test_preflight_duplicate_indexes.py

@@ -0,0 +1,102 @@
+"""Unit tests for `_collect_model_indexes` — the helper that feeds
+`postgres.duplicate_indexes`. Partial indexes/constraints must be
+excluded so the check doesn't contradict `postgres.missing_fk_indexes`,
+which already treats partials as non-covering.
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+from plain.postgres import Q
+from plain.postgres.constraints import UniqueConstraint
+from plain.postgres.indexes import Index
+from plain.postgres.preflight import _collect_model_indexes
+
+
+def _model(*, indexes=(), constraints=()) -> SimpleNamespace:
+    """Minimal model_options stand-in for the helper."""
+    return SimpleNamespace(
+        model_options=SimpleNamespace(
+            indexes=list(indexes), constraints=list(constraints)
+        )
+    )
+
+
+def _names(collected) -> set[str]:
+    return {name for name, _fields, _unique in collected}
+
+
+def test_non_partial_index_collected():
+    model = _model(indexes=[Index(name="t_team_idx", fields=["team"])])
+    assert _names(_collect_model_indexes(model)) == {"t_team_idx"}
+
+
+def test_non_partial_unique_constraint_collected():
+    model = _model(constraints=[UniqueConstraint(fields=["team"], name="t_team_uniq")])
+    assert _names(_collect_model_indexes(model)) == {"t_team_uniq"}
+
+
+def test_partial_index_excluded():
+    model = _model(
+        indexes=[
+            Index(
+                name="t_team_open_idx",
+                fields=["team", "created_at"],
+                condition=Q(resolved_at__isnull=True),
+            )
+        ]
+    )
+    assert _collect_model_indexes(model) == []
+
+
+def test_partial_unique_constraint_excluded():
+    model = _model(
+        constraints=[
+            UniqueConstraint(
+                fields=["team"],
+                name="t_team_active_uniq",
+                condition=Q(deleted_at__isnull=True),
+            )
+        ]
+    )
+    assert _collect_model_indexes(model) == []
+
+
+def test_bare_index_not_flagged_against_partial_prefix():
+    """A bare `Index(fields=[fk])` carried for FK coverage must survive
+    alongside a partial composite `Index(fields=[fk, other], condition=...)`
+    — otherwise the duplicate check fights the missing-FK check."""
+    model = _model(
+        indexes=[
+            Index(name="t_team_idx", fields=["team"]),
+            Index(
+                name="t_team_open_idx",
+                fields=["team", "created_at"],
+                condition=Q(resolved_at__isnull=True),
+            ),
+        ]
+    )
+    assert _names(_collect_model_indexes(model)) == {"t_team_idx"}
+
+
+def test_mixed_keeps_only_non_partial():
+    model = _model(
+        indexes=[
+            Index(name="t_a_idx", fields=["a"]),
+            Index(
+                name="t_a_partial_idx",
+                fields=["a"],
+                condition=Q(deleted_at__isnull=True),
+            ),
+        ],
+        constraints=[
+            UniqueConstraint(fields=["b"], name="t_b_uniq"),
+            UniqueConstraint(
+                fields=["b"],
+                name="t_b_active_uniq",
+                condition=Q(deleted_at__isnull=True),
+            ),
+        ],
+    )
+    assert _names(_collect_model_indexes(model)) == {"t_a_idx", "t_b_uniq"}