plain.postgres 0.103.2__tar.gz → 0.103.4__tar.gz

{plain_postgres-0.103.2 → 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.2 → plain_postgres-0.103.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.postgres
-Version: 0.103.2
+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.2 → plain_postgres-0.103.4}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,26 @@
 # 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
+
+- **`QuerySet.__repr__` no longer issues SQL for unevaluated querysets.** Error reporters (Sentry, pdb, exception templates) call `repr()` on stack-frame locals to build error events, and a surprise `SELECT … LIMIT 21` inside an exception path is a known footgun — especially on production where the underlying query may itself be the cause of the failure. Unevaluated querysets now render as `<QuerySet [unevaluated]>`; once the result cache is populated, `repr()` formats from the cache as before (still truncating past 20 rows). ([d8b7c4ec30](https://github.com/dropseed/plain/commit/d8b7c4ec30))
+- **`ManyToManyField.value_from_object` no longer calls `.all()` on a manager.** The form-roundtrip path went through `getattr(obj, attname).all()`, which on the M2M manager dispatched to its descriptor and could trigger an unintended fetch/SQL path. Switched to the manager's `.query` queryset, which is the documented entry point. ([83da86b19b](https://github.com/dropseed/plain/commit/83da86b19b))
+
+### Upgrade instructions
+
+- No changes required. Note that interactive shell users who relied on `repr()` triggering evaluation (e.g., typing `qs` at the prompt to print rows) will now see `<QuerySet [unevaluated]>` — call `list(qs)` or slice it to materialize.
+
 ## [0.103.2](https://github.com/dropseed/plain/releases/plain-postgres@0.103.2) (2026-05-06)
 
 ### What's changed

{plain_postgres-0.103.2 → plain_postgres-0.103.4}/plain/postgres/fields/related.py

@@ -1174,7 +1174,7 @@ class ManyToManyField(RelatedField):
         pass
 
     def value_from_object(self, obj: Model) -> list[Any]:
-        return [] if obj.id is None else list(getattr(obj, self.attname).all())
+        return [] if obj.id is None else list(getattr(obj, self.attname).query)
 
     def save_form_data(self, instance: Model, data: Any) -> None:
         getattr(instance, self.attname).set(data)

{plain_postgres-0.103.2 → 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.2 → plain_postgres-0.103.4}/plain/postgres/query.py

@@ -380,7 +380,13 @@ class QuerySet[T: "Model"]:
         self.__dict__.update(state)
 
     def __repr__(self) -> str:
-        data: list[Any] = list(self[: REPR_OUTPUT_SIZE + 1])
+        # Don't run SQL from __repr__ — error reporters (Sentry, pdb,
+        # exception templates) call repr() on stack-frame locals to
+        # build error events. If the queryset hasn't been evaluated, a
+        # surprise SELECT inside an exception path is a known footgun.
+        if self._result_cache is None:
+            return f"<{self.__class__.__name__} [unevaluated]>"
+        data: list[Any] = list(self._result_cache[: REPR_OUTPUT_SIZE + 1])
         if len(data) > REPR_OUTPUT_SIZE:
             data[-1] = "...(remaining elements truncated)..."
         return f"<{self.__class__.__name__} {data!r}>"

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

@@ -1,6 +1,6 @@
 [project]
 name = "plain.postgres"
-version = "0.103.2"
+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.2 → 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.2 → 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"}

{plain_postgres-0.103.2 → plain_postgres-0.103.4}/tests/public/test_m2m.py

@@ -5,10 +5,13 @@ exercise ManyToManyField accessors, the through model, and the Widget-specific
 unique constraint that produces a realistic ValidationError on duplicate create.
 """
 
+from typing import cast
+
 import pytest
 from app.examples.models.relationships import Tag, Widget, WidgetTag
 
 from plain.exceptions import ValidationError
+from plain.postgres.fields.related import ManyToManyField
 
 
 def test_create_unique_constraint(db):
@@ -94,6 +97,32 @@ def test_many_to_many_clear(db):
     assert widget.tags.query.count() == 0
 
 
+def test_value_from_object_returns_related_objects(db):
+    """ManyToManyField.value_from_object must return the currently-related
+    objects. ModelForm's `model_to_dict` calls this when given an instance
+    so the form can populate `initial` for the M2M field — a regression
+    here breaks UpdateView for any model with an M2M.
+    """
+    widget = Widget.query.create(name="Subaru", size="Outback")
+    gps = Tag.query.create(name="GPS")
+    sunroof = Tag.query.create(name="Sunroof")
+    widget.tags.add(gps, sunroof)
+
+    field = cast(ManyToManyField, Widget._model_meta.get_forward_field("tags"))
+    result = field.value_from_object(widget)
+
+    assert {t.name for t in result} == {"GPS", "Sunroof"}
+
+
+def test_value_from_object_unsaved_instance_returns_empty(db):
+    """An unsaved instance has no related rows; value_from_object should
+    return an empty list rather than crash.
+    """
+    widget = Widget(name="Mazda", size="3")
+    field = cast(ManyToManyField, Widget._model_meta.get_forward_field("tags"))
+    assert list(field.value_from_object(widget)) == []
+
+
 def test_many_to_many_through_model(db):
     """Test accessing the through model directly."""
     widget = Widget.query.create(name="Ford", size="Mustang")

plain_postgres-0.103.4/tests/public/test_queryset_repr.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from app.examples.models.iteration import IterationExample
+
+from plain.postgres.db import get_connection
+
+
+def _capture_queries(callable_):
+    conn = get_connection()
+    prev_force = conn.force_debug_cursor
+    conn.force_debug_cursor = True
+    conn.queries_log.clear()
+    try:
+        callable_()
+        return list(conn.queries_log)
+    finally:
+        conn.force_debug_cursor = prev_force
+
+
+def test_repr_does_not_execute_sql_when_unevaluated(db):
+    """repr() of an unevaluated queryset must not issue a SQL query.
+
+    Error reporters (Sentry, pdb, exception templates) call repr() on
+    stack-frame locals; a surprise SELECT inside an exception path can
+    overload the database.
+    """
+    qs = IterationExample.query.all()
+
+    queries = _capture_queries(lambda: repr(qs))
+
+    assert queries == []
+    assert repr(qs) == "<QuerySet [unevaluated]>"
+
+
+def test_repr_uses_cache_when_evaluated(db):
+    """Once a queryset is evaluated, repr() reflects its rows without re-querying."""
+    IterationExample.query.create(name="alpha", tag="a")
+    IterationExample.query.create(name="beta", tag="b")
+
+    qs = IterationExample.query.all()
+    list(qs)  # force evaluation, populates _result_cache
+
+    queries = _capture_queries(lambda: repr(qs))
+
+    assert queries == []
+    rendered = repr(qs)
+    assert "[unevaluated]" not in rendered
+    assert rendered.count("IterationExample") == 2
+
+
+def test_repr_truncates_large_evaluated_querysets(db):
+    """The truncation marker still appears past REPR_OUTPUT_SIZE."""
+    for i in range(25):
+        IterationExample.query.create(name=f"name{i:02d}", tag="t")
+
+    qs = IterationExample.query.all()
+    list(qs)
+
+    rendered = repr(qs)
+    assert "remaining elements truncated" in rendered