fix(fixer): exclude Python class sentinels from save update_fields inference

The save_without_update_fields fixer was including Python class attributes
(e.g. no_changes = False) in the inferred update_fields list, causing
FieldDoesNotExist errors at runtime on Django 1.11+ since those attributes
are not database columns.

Add _collect_non_field_class_attrs() which scans every class definition in
the module and returns attribute names that are NOT assigned to models.XYZField(...)
instances. These sentinels are excluded from the update_fields suggestion.

Root cause: celery/django-celery#643 CI failure (Python 3.7/Django 1.11
matrix) — our PR included no_changes in update_fields. Fixed in the
django-celery fork (commit 01d5ea9) and now pact itself won't generate
this invalid repair in future.

Two regression tests: sentinel excluded, all-sentinel case → skipped.
305 tests passing.

Author: qizwiz

fixer.py

@@ -516,6 +516,49 @@ def _obj_name(node: ast.expr) -> str | None:
     return None
 
 
+def _collect_non_field_class_attrs(tree: ast.Module) -> frozenset[str]:
+    """
+    Collect attribute names that are assigned simple Python values (not Django
+    Field instances) at class-body level in any class in the module.
+
+    These are Python sentinels / class constants (e.g. `no_changes = False`,
+    `objects = Manager()`, `Meta = ...`) — not real database columns.  When
+    pact infers `update_fields` from preceding attribute assignments it must
+    exclude these, or Django raises FieldDoesNotExist at runtime.
+
+    Pattern detected:
+        class SomeModel(models.Model):
+            real_field = models.CharField(...)   ← NOT collected (is a Field)
+            no_changes = False                   ← collected (simple value)
+            _state  = ...                        ← collected (non-Field)
+    """
+    non_fields: set[str] = set()
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ClassDef):
+            continue
+        for stmt in node.body:
+            if not isinstance(stmt, ast.Assign):
+                continue
+            if len(stmt.targets) != 1:
+                continue
+            target = stmt.targets[0]
+            if not isinstance(target, ast.Name):
+                continue
+            val = stmt.value
+            # If the value is a call whose function name ends in "Field", it's a
+            # real Django field definition — skip it.
+            if isinstance(val, ast.Call):
+                func = val.func
+                is_field = (
+                    isinstance(func, ast.Attribute) and func.attr.endswith("Field")
+                ) or (isinstance(func, ast.Name) and func.id.endswith("Field"))
+                if is_field:
+                    continue
+            # Not a Field call — this is a Python class attribute / sentinel.
+            non_fields.add(target.id)
+    return frozenset(non_fields)
+
+
 def _collect_preceding_assignments(
     func_body: list[ast.stmt],
     save_lineno: int,
@@ -599,6 +642,10 @@ def _fix_save_without_update_fields(
         skipped.extend(violations)
         return list(lines), applied, skipped
 
+    # Attrs that are Python class constants / sentinels (not Django Fields).
+    # These must never appear in update_fields — Django would raise FieldDoesNotExist.
+    sentinel_attrs = _collect_non_field_class_attrs(tree)
+
     # Build map: save_lineno → enclosing function body
     save_line_to_func: dict[int, list[ast.stmt]] = {}
     for node in ast.walk(tree):
@@ -647,6 +694,12 @@ def _fix_save_without_update_fields(
             skipped.append(ev)
             continue
 
+        # Filter out Python sentinels — keep only real DB columns.
+        attrs = [a for a in attrs if a not in sentinel_attrs]
+        if not attrs:
+            skipped.append(ev)
+            continue
+
         # Build `update_fields=[...]` argument string
         fields_list = "[" + ", ".join(f'"{a}"' for a in reversed(attrs)) + "]"
 

test_fixer.py

@@ -707,6 +707,51 @@ def update(obj):
     assert not result.changed or "update_fields" in result.patched
 
 
+def test_save_excludes_python_sentinel_attrs(tmp_path):
+    """Regression: class-level Python sentinels (not models.Field) excluded from update_fields.
+
+    Root cause of celery/django-celery#643 CI failure: pact inferred
+    `update_fields=['no_changes', 'enabled']` but `no_changes = False` is a
+    Python class attribute, not a DB column — Django raises FieldDoesNotExist.
+    """
+    src = textwrap.dedent("""\
+        class PeriodicTask(models.Model):
+            enabled = models.BooleanField(default=True)
+            no_changes = False
+
+        def _disable(model):
+            model.no_changes = True
+            model.enabled = False
+            model.save()
+    """)
+    f = tmp_path / "s.py"
+    f.write_text(src)
+    ev = _ev("save_without_update_fields", 8, "model.save", str(f))
+    result = fix_file(str(f), [ev])
+    assert result.changed
+    assert 'update_fields=["enabled"]' in result.patched
+    assert "no_changes" not in result.patched.split("update_fields=")[1]
+    ast.parse(result.patched)
+
+
+def test_save_all_sentinel_attrs_skipped(tmp_path):
+    """If all inferred attrs are sentinels, skip rather than emit empty update_fields."""
+    src = textwrap.dedent("""\
+        class Task(models.Model):
+            _sentinel = None
+
+        def update(obj):
+            obj._sentinel = True
+            obj.save()
+    """)
+    f = tmp_path / "s.py"
+    f.write_text(src)
+    ev = _ev("save_without_update_fields", 5, "obj.save", str(f))
+    result = fix_file(str(f), [ev])
+    assert not result.changed
+    assert len(result.skipped) == 1
+
+
 # ---------------------------------------------------------------------------
 # unvalidated_lookup_chain
 # ---------------------------------------------------------------------------