plain.postgres 0.103.2__tar.gz → 0.103.3__tar.gz

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

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

@@ -1,5 +1,16 @@
 # plain-postgres changelog
 
+## [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.3}/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.3}/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.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.postgres"
-version = "0.103.2"
+version = "0.103.3"
 description = "Model your data and store it in a database."
 authors = [{ name = "Dave Gaeddert", email = "dave.gaeddert@dropseed.dev" }]
 readme = "README.md"

{plain_postgres-0.103.2 → plain_postgres-0.103.3}/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.3/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