plain.postgres 0.106.0__tar.gz → 0.107.1__tar.gz

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.postgres
-Version: 0.106.0
+Version: 0.107.1
 Summary: Model your data and store it in a database.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-Expression: BSD-3-Clause
@@ -1066,7 +1066,7 @@ except ValidationError:
     ...  # report it — the transaction is still usable
 ```
 
-Forms are the exception: a `ModelForm` pre-checks constraints explicitly (a `validate_constraints()` call in its `_post_clean`) so it can surface every violation at once, then saves with validation already done. A direct `create()`/`update()` reports the first violation Postgres hits.
+Forms are the exception: a `ModelForm` pre-checks constraints explicitly (a `validate_constraints()` call in its `_post_clean`) so it can surface every violation at once, then writes via `form.create()`/`form.update()` with validation already done. A direct `create()`/`update()` reports the first violation Postgres hits.
 
 This applies to instance writes only. Set-based writes — `QuerySet.update()` and `bulk_create()` — raise the raw `psycopg.IntegrityError`, since there's no instance to attribute the error to. If you retry on a unique conflict, catch both:
 
@@ -1234,7 +1234,7 @@ class UserForm(forms.ModelForm):
 # Usage
 form = UserForm(request=request)
 if form.is_valid():
-    user = form.save()
+    user = form.create()
 ```
 
 ## Architecture

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,33 @@
 # plain-postgres changelog
 
+## [0.107.1](https://github.com/dropseed/plain/releases/plain-postgres@0.107.1) (2026-06-08)
+
+### What's changed
+
+- Internal: typing-only cleanup for the `ty` 0.0.45 upgrade. `Query.order_by` is now annotated `tuple[Any, ...]` instead of relying on empty-tuple inference, a few field-name dict keys are narrowed via `assert` or the known-`str` loop variable, and `ty: ignore` comments on the intentionally heterogeneous `get_fields()` / `klass_info` structures were adjusted (net removal of several ignores). No runtime behavior changes. ([5c8015795d](https://github.com/dropseed/plain/commit/5c8015795d), [95f54e880d](https://github.com/dropseed/plain/commit/95f54e880d))
+
+### Upgrade instructions
+
+- No changes required.
+
+## [0.107.0](https://github.com/dropseed/plain/releases/plain-postgres@0.107.0) (2026-06-07)
+
+### What's changed
+
+- **`ModelForm.save()` is replaced by explicit `create()` and `update()`**, mirroring the `Model.create()`/`update()` split from 0.106.0. The view already knows whether it's inserting or updating (`CreateView` vs `UpdateView`), so the form no longer branches on `instance._state.adding` to guess. `form.create()` INSERTs the instance (and its m2m data) and returns it; `form.update(fields=None)` UPDATEs it (and its m2m data) and returns it, with `fields=[...]` passed straight through to `Model.update()` to limit the columns written. `save(commit=...)` — including the `commit=False` deferred path — is removed. ([66634f5af9](https://github.com/dropseed/plain/commit/66634f5af9))
+
+### Upgrade instructions
+
+- Replace `form.save()` with `form.create()` in create flows and `form.update()` in update flows. The `/plain-upgrade` skill rewrites these for you — the create-vs-update choice is context-dependent, so it reasons per call site.
+- `form.update(fields=[...])` is available to limit the columns written (a pass-through to `Model.update(fields=...)`).
+- For the old `form.save(commit=False)` pattern (set extra non-form attributes, then save), assign those attributes on `form.instance` after `is_valid()`, then call `form.create()` / `form.update()` — m2m data is still saved for you, so the separate `save_m2m()` step is no longer needed:
+
+    ```python
+    if form.is_valid():
+        form.instance.user = request.user
+        obj = form.create()
+    ```
+
 ## [0.106.0](https://github.com/dropseed/plain/releases/plain-postgres@0.106.0) (2026-06-03)
 
 ### What's changed

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/plain/postgres/README.md

@@ -1053,7 +1053,7 @@ except ValidationError:
     ...  # report it — the transaction is still usable
 ```
 
-Forms are the exception: a `ModelForm` pre-checks constraints explicitly (a `validate_constraints()` call in its `_post_clean`) so it can surface every violation at once, then saves with validation already done. A direct `create()`/`update()` reports the first violation Postgres hits.
+Forms are the exception: a `ModelForm` pre-checks constraints explicitly (a `validate_constraints()` call in its `_post_clean`) so it can surface every violation at once, then writes via `form.create()`/`form.update()` with validation already done. A direct `create()`/`update()` reports the first violation Postgres hits.
 
 This applies to instance writes only. Set-based writes — `QuerySet.update()` and `bulk_create()` — raise the raw `psycopg.IntegrityError`, since there's no instance to attribute the error to. If you retry on a unique conflict, catch both:
 
@@ -1221,7 +1221,7 @@ class UserForm(forms.ModelForm):
 # Usage
 form = UserForm(request=request)
 if form.is_valid():
-    user = form.save()
+    user = form.create()
 ```
 
 ## Architecture

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/plain/postgres/constraints.py

@@ -385,7 +385,7 @@ class UniqueConstraint(BaseConstraint):
                     # A composite constraint containing NULL value cannot cause
                     # a violation since NULL != NULL in SQL.
                     return
-                lookup_kwargs[field.name] = lookup_value
+                lookup_kwargs[field_name] = lookup_value
             queryset = queryset.filter(**lookup_kwargs)
         else:
             # Ignore constraints with excluded fields.

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/plain/postgres/forms.py

@@ -5,6 +5,7 @@ and database field objects.
 
 from __future__ import annotations
 
+from collections.abc import Iterable
 from itertools import chain
 from typing import TYPE_CHECKING, Any, cast
 
@@ -380,30 +381,36 @@ class BaseModelForm(BaseForm):
             if f.name in cleaned_data:
                 f.save_form_data(self.instance, cleaned_data[f.name])
 
-    def save(self, commit: bool = True) -> Any:
-        """
-        Save this form's self.instance object if commit=True. Otherwise, add
-        a save_m2m() method to the form which can be called after the instance
-        is saved manually at a later time. Return the model instance.
-        """
+    def _raise_if_invalid(self, action: str) -> None:
+        """Guard the write methods -- a form with errors can't be persisted."""
         if self.errors:
             raise ValueError(
-                "The {} could not be {} because the data didn't validate.".format(
-                    self.instance.model_options.object_name,
-                    "created" if self.instance._state.adding else "changed",
-                )
+                f"The {self.instance.model_options.object_name} could not be "
+                f"{action} because the data didn't validate."
             )
-        if commit:
-            # If committing, persist the instance and the m2m data immediately.
-            if self.instance._state.adding:
-                self.instance.create(clean_and_validate=False)
-            else:
-                self.instance.update(clean_and_validate=False)
-            self._save_m2m()
-        else:
-            # If not committing, add a method to the form to allow deferred
-            # saving of m2m data.
-            self.save_m2m = self._save_m2m
+
+    def create(self) -> Any:
+        """INSERT this form's instance (and its m2m data) and return it.
+
+        Shape and constraints were already validated in _post_clean, so the
+        write trusts them (clean_and_validate=False). This mirrors
+        Model.create(); use it from a create flow and update() to UPDATE.
+        """
+        self._raise_if_invalid("created")
+        self.instance.create(clean_and_validate=False)
+        self._save_m2m()
+        return self.instance
+
+    def update(self, *, fields: Iterable[str] | None = None) -> Any:
+        """UPDATE this form's instance (and its m2m data) and return it.
+
+        `fields` is passed straight through to Model.update() to limit the
+        columns written; the default writes every loaded field. Validation
+        already ran in _post_clean, so the write trusts it.
+        """
+        self._raise_if_invalid("changed")
+        self.instance.update(clean_and_validate=False, fields=fields)
+        self._save_m2m()
         return self.instance
 
 

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/plain/postgres/meta.py

@@ -511,8 +511,9 @@ class Meta:
                 fields.append(field.remote_field)
 
         if forward:
-            fields += self.local_fields
-            fields += self.local_many_to_many
+            # get_fields() intentionally returns a heterogeneous list of field types.
+            fields += self.local_fields  # ty: ignore[unsupported-operator]
+            fields += self.local_many_to_many  # ty: ignore[unsupported-operator]
 
         # In order to avoid list manipulation. Always
         # return a shallow copy of the results

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/plain/postgres/migrations/executor.py

@@ -47,7 +47,7 @@ class MigrationExecutor:
                 if migration not in applied:
                     plan.append(self.loader.graph.nodes[migration])
                     applied[migration] = self.loader.graph.nodes[migration]
-        return plan
+        return plan  # ty: ignore[invalid-return-type] (graph.nodes may hold dummy None, never reached here)
 
     def _create_project_state(
         self, with_applied_migrations: bool = False

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/plain/postgres/migrations/state.py

@@ -679,6 +679,7 @@ class ModelState:
             if getattr(field, "remote_field", None) and exclude_rels:
                 continue
             name = field.name
+            assert name is not None
             try:
                 fields.append((name, field.clone()))
             except TypeError as e:
@@ -688,6 +689,7 @@ class ModelState:
         if not exclude_rels:
             for field in model._model_meta.local_many_to_many:
                 name = field.name
+                assert name is not None
                 try:
                     fields.append((name, field.clone()))
                 except TypeError as e:
@@ -699,7 +701,7 @@ class ModelState:
             bases = []
             for base in model.__bases__:
                 bases.append(base)
-            return bases
+            return bases  # ty: ignore[invalid-return-type] (__bases__ widens to list[type])
 
         # We can't rely on __mro__ directly because we only want to flatten
         # abstract models and not the whole tree. However by recursing on

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/plain/postgres/query.py

@@ -809,6 +809,7 @@ class QuerySet[T: "Model"]:
                 case_statement = Case(*when_statements, output_field=field)
                 # PostgreSQL requires casted CASE in updates
                 case_statement = Cast(case_statement, output_field=field)
+                assert field.name is not None
                 update_kwargs[field.name] = case_statement
             updates.append(([obj.id for obj in batch_objs], update_kwargs))
         rows_updated = 0

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/plain/postgres/sql/compiler.py

@@ -343,7 +343,7 @@ class SQLCompiler:
         if self.query.select_related:
             related_klass_infos = self.get_related_selections(select, select_mask)
             if klass_info is not None:
-                klass_info["related_klass_infos"] = related_klass_infos
+                klass_info["related_klass_infos"] = related_klass_infos  # ty: ignore[invalid-assignment] (heterogeneous klass_info dict)
 
         ret = []
         col_idx = 1
@@ -367,7 +367,7 @@ class SQLCompiler:
                 alias = f"col{col_idx}"
                 col_idx += 1
             ret.append((col, (sql, params), alias))
-        return ret, klass_info, annotations
+        return ret, klass_info, annotations  # ty: ignore[invalid-return-type] (heterogeneous klass_info dict)
 
     def _order_by_pairs(self) -> Generator[tuple[OrderBy, bool]]:
         if self.query.extra_order_by:

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/plain/postgres/sql/query.py

@@ -229,7 +229,9 @@ class Query(BaseExpression):
     #  - True: group by all select fields of the model
     # See compiler.get_group_by() for details.
     group_by = None
-    order_by = ()
+    # Holds field-name strings and order expressions; the compiler duck-types
+    # each entry, so the element type is intentionally loose.
+    order_by: tuple[Any, ...] = ()
     low_mark = 0  # Used for offset/limit.
     high_mark = None  # Used for offset/limit.
     distinct = False

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.postgres"
-version = "0.106.0"
+version = "0.107.1"
 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.106.0 → plain_postgres-0.107.1}/tests/app/examples/urls.py

@@ -18,6 +18,11 @@ class ExamplesRouter(Router):
             views.FormsExampleUpdateView,
             name="forms_update",
         ),
+        path(
+            "forms/<int:pk>/delete",
+            views.FormsExampleDeleteView,
+            name="forms_delete",
+        ),
         path(
             "child-cascade/create",
             views.ChildCascadeCreateView,

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/tests/app/examples/views.py

@@ -4,7 +4,7 @@ import json
 from typing import Any
 
 from plain.http import Response
-from plain.templates.views import CreateView, UpdateView
+from plain.templates.views import CreateView, DeleteView, UpdateView
 
 from .forms import (
     ChildCascadeForm,
@@ -52,6 +52,13 @@ class FormsExampleUpdateView(_NoTemplateFormView, UpdateView):
         return FormsExample.query.filter(id=self.url_kwargs["pk"]).first()
 
 
+class FormsExampleDeleteView(_NoTemplateFormView, DeleteView):
+    success_url = "/ok/"
+
+    def get_object(self) -> Any:
+        return FormsExample.query.filter(id=self.url_kwargs["pk"]).first()
+
+
 class ChildCascadeCreateView(_NoTemplateFormView, CreateView):
     form_class = ChildCascadeForm
     success_url = "/ok/"

{plain_postgres-0.106.0 → plain_postgres-0.107.1}/tests/public/test_modelform_roundtrip.py

@@ -181,6 +181,34 @@ class TestFormsExampleUpdate:
         assert existing.count == 1
 
 
+class TestFormsExampleDelete:
+    """DeleteView posts an empty confirmation form; the view deletes the row."""
+
+    def _create_existing(self) -> FormsExample:
+        return FormsExample.query.create(
+            name="Doomed",
+            status="draft",
+            count=1,
+            ratio=0.5,
+            amount=Decimal("1.00"),
+            event_date=datetime.date(2020, 1, 1),
+            event_time=datetime.time(0, 0, 0),
+            event_datetime=datetime.datetime(2020, 1, 1, 0, 0, 0, tzinfo=datetime.UTC),
+            duration=datetime.timedelta(minutes=1),
+            external_id=uuid.UUID("00000000-0000-0000-0000-000000000002"),
+        )
+
+    def test_delete_removes_the_row(self, db):
+        existing = self._create_existing()
+        client = Client()
+
+        response = client.post(f"/examples/forms/{existing.id}/delete")
+
+        assert response.status_code == 302, response.content
+        assert response.headers["Location"] == "/ok/"
+        assert not FormsExample.query.filter(id=existing.id).exists()
+
+
 class TestForeignKeyRoundTrip:
     """Exercises the explicit ForeignKeyField → ModelChoiceField handler."""