arthexis 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

core/views.py

@@ -1,3 +1,5 @@
+import base64
+import binascii
 import json
 import logging
 import os
@@ -16,6 +18,7 @@ from django.http import Http404, JsonResponse, HttpResponse
 from django.shortcuts import get_object_or_404, redirect, render, resolve_url
 from django.template.response import TemplateResponse
 from django.utils import timezone
+from django.utils.html import strip_tags
 from django.utils.text import slugify
 from django.utils.translation import gettext as _
 from django.urls import NoReverseMatch, reverse
@@ -32,6 +35,7 @@ from django.template.loader import get_template
 from django.test import signals
 
 from utils import revision
+from nodes.utils import save_screenshot
 from utils.api import api_login_required
 
 logger = logging.getLogger(__name__)
@@ -633,6 +637,8 @@ def _write_todo_fixture(todo: Todo) -> Path:
                 "request": todo.request,
                 "url": todo.url,
                 "request_details": todo.request_details,
+                "generated_for_version": todo.generated_for_version,
+                "generated_for_revision": todo.generated_for_revision,
             },
         }
     ]
@@ -650,8 +656,8 @@ def _should_use_python_changelog(exc: OSError) -> bool:
 def _generate_changelog_with_python(log_path: Path) -> None:
     _append_log(log_path, "Falling back to Python changelog generator")
     changelog_path = Path("CHANGELOG.rst")
-    range_spec = changelog_utils.determine_range_spec()
     previous = changelog_path.read_text(encoding="utf-8") if changelog_path.exists() else None
+    range_spec = changelog_utils.determine_range_spec(previous_text=previous)
     sections = changelog_utils.collect_sections(range_spec=range_spec, previous_text=previous)
     content = changelog_utils.render_changelog(sections)
     if not content.endswith("\n"):
@@ -666,9 +672,16 @@ def _ensure_release_todo(
     previous_version = (previous_version or "").strip()
     target_version = _next_patch_version(release.version)
     if previous_version:
-        incremented_previous = _next_patch_version(previous_version)
-        if incremented_previous == release.version:
-            target_version = release.version
+        try:
+            from packaging.version import InvalidVersion, Version
+
+            parsed_previous = Version(previous_version)
+            parsed_target = Version(target_version)
+        except InvalidVersion:
+            pass
+        else:
+            if parsed_target <= parsed_previous:
+                target_version = _next_patch_version(previous_version)
     request = f"Create release {release.package.name} {target_version}"
     try:
         url = reverse("admin:core_packagerelease_changelist")
@@ -680,6 +693,8 @@ def _ensure_release_todo(
             "request": request,
             "url": url,
             "request_details": "",
+            "generated_for_version": release.version or "",
+            "generated_for_revision": release.revision or "",
             "is_seed_data": True,
             "is_deleted": False,
             "is_user_data": False,
@@ -815,14 +830,88 @@ def _get_return_url(request) -> str:
     return resolve_url("admin:index")
 
 
+def _refresh_changelog_once(ctx, log_path: Path) -> None:
+    """Regenerate the changelog a single time per release run."""
+
+    if ctx.get("changelog_refreshed"):
+        return
+
+    _append_log(log_path, "Refreshing changelog before TODO review")
+    try:
+        subprocess.run(["scripts/generate-changelog.sh"], check=True)
+    except OSError as exc:
+        if _should_use_python_changelog(exc):
+            _append_log(
+                log_path,
+                f"scripts/generate-changelog.sh failed: {exc}",
+            )
+            _generate_changelog_with_python(log_path)
+        else:  # pragma: no cover - unexpected OSError
+            raise
+    else:
+        _append_log(
+            log_path,
+            "Regenerated CHANGELOG.rst using scripts/generate-changelog.sh",
+        )
+
+    staged_paths: list[str] = []
+    changelog_path = Path("CHANGELOG.rst")
+    if changelog_path.exists():
+        staged_paths.append(str(changelog_path))
+
+    release_fixtures = sorted(Path("core/fixtures").glob("releases__*.json"))
+    staged_paths.extend(str(path) for path in release_fixtures)
+
+    if staged_paths:
+        subprocess.run(["git", "add", *staged_paths], check=True)
+
+    diff = subprocess.run(
+        ["git", "diff", "--cached", "--name-only"],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    changed_paths = [line.strip() for line in diff.stdout.splitlines() if line.strip()]
+
+    if changed_paths:
+        changelog_dirty = "CHANGELOG.rst" in changed_paths
+        fixtures_dirty = any(path.startswith("core/fixtures/") for path in changed_paths)
+        if changelog_dirty and fixtures_dirty:
+            message = "chore: sync release fixtures and changelog"
+        elif changelog_dirty:
+            message = "docs: refresh changelog"
+        else:
+            message = "chore: update release fixtures"
+        subprocess.run(["git", "commit", "-m", message], check=True)
+        _append_log(log_path, f"Committed changelog refresh ({message})")
+    else:
+        _append_log(log_path, "Changelog already up to date")
+
+    ctx["changelog_refreshed"] = True
+
+
 def _step_check_todos(release, ctx, log_path: Path) -> None:
+    _refresh_changelog_once(ctx, log_path)
+
     pending_qs = Todo.objects.filter(is_deleted=False, done_on__isnull=True)
-    if pending_qs.exists():
-        ctx["todos"] = list(
-            pending_qs.values("id", "request", "url", "request_details")
-        )
-        if not ctx.get("todos_ack"):
-            raise PendingTodos()
+    pending_values = list(
+        pending_qs.values("id", "request", "url", "request_details")
+    )
+    if not pending_values:
+        ctx["todos_ack"] = True
+
+    if not ctx.get("todos_ack"):
+        if not ctx.get("todos_block_logged"):
+            _append_log(
+                log_path,
+                "Release checklist requires acknowledgment before continuing. "
+                "Review outstanding TODO items and confirm the checklist; "
+                "publishing will resume automatically afterward.",
+            )
+            ctx["todos_block_logged"] = True
+        ctx["todos"] = pending_values
+        ctx["todos_required"] = True
+        raise PendingTodos()
     todos = list(Todo.objects.filter(is_deleted=False))
     for todo in todos:
         todo.delete()
@@ -837,6 +926,7 @@ def _step_check_todos(release, ctx, log_path: Path) -> None:
             check=False,
         )
     ctx.pop("todos", None)
+    ctx.pop("todos_required", None)
     ctx["todos_ack"] = True
 
 
@@ -860,9 +950,12 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
             if "fixtures" in Path(f).parts and Path(f).suffix == ".json"
         ]
         changelog_dirty = "CHANGELOG.rst" in files
+        version_dirty = "VERSION" in files
         allowed_dirty_files = set(fixture_files)
         if changelog_dirty:
             allowed_dirty_files.add("CHANGELOG.rst")
+        if version_dirty:
+            allowed_dirty_files.add("VERSION")
 
         if files and len(allowed_dirty_files) == len(files):
             summary = []
@@ -895,6 +988,8 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
             commit_paths = [*fixture_files]
             if changelog_dirty:
                 commit_paths.append("CHANGELOG.rst")
+            if version_dirty:
+                commit_paths.append("VERSION")
 
             log_fragments = []
             if fixture_files:
@@ -903,6 +998,8 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
                 )
             if changelog_dirty:
                 log_fragments.append("CHANGELOG.rst")
+            if version_dirty:
+                log_fragments.append("VERSION")
             details = ", ".join(log_fragments) if log_fragments else "changes"
             _append_log(
                 log_path,
@@ -910,8 +1007,16 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
             )
             subprocess.run(["git", "add", *commit_paths], check=True)
 
-            if changelog_dirty and fixture_files:
+            if changelog_dirty and version_dirty and fixture_files:
+                commit_message = "chore: sync release metadata"
+            elif changelog_dirty and version_dirty:
+                commit_message = "chore: update version and changelog"
+            elif version_dirty and fixture_files:
+                commit_message = "chore: update version and fixtures"
+            elif changelog_dirty and fixture_files:
                 commit_message = "chore: sync release fixtures and changelog"
+            elif version_dirty:
+                commit_message = "chore: update version"
             elif changelog_dirty:
                 commit_message = "docs: refresh changelog"
             else:
@@ -1023,6 +1128,36 @@ def _step_changelog_docs(release, ctx, log_path: Path) -> None:
     _append_log(log_path, "CHANGELOG and documentation review recorded")
 
 
+def _record_release_todo(
+    release, ctx, log_path: Path, *, previous_version: str | None = None
+) -> None:
+    previous_version = previous_version or ctx.pop(
+        "release_todo_previous_version",
+        getattr(release, "_repo_version_before_sync", ""),
+    )
+    todo, fixture_path = _ensure_release_todo(
+        release, previous_version=previous_version
+    )
+    fixture_display = _format_path(fixture_path)
+    _append_log(log_path, f"Added TODO: {todo.request}")
+    _append_log(log_path, f"Wrote TODO fixture {fixture_display}")
+    subprocess.run(["git", "add", str(fixture_path)], check=True)
+    _append_log(log_path, f"Staged TODO fixture {fixture_display}")
+    fixture_diff = subprocess.run(
+        ["git", "diff", "--cached", "--quiet", "--", str(fixture_path)],
+        check=False,
+    )
+    if fixture_diff.returncode != 0:
+        commit_message = f"chore: add release TODO for {release.package.name}"
+        subprocess.run(["git", "commit", "-m", commit_message], check=True)
+        _append_log(log_path, f"Committed TODO fixture {fixture_display}")
+    else:
+        _append_log(
+            log_path,
+            f"No changes detected for TODO fixture {fixture_display}; skipping commit",
+        )
+
+
 def _step_pre_release_actions(release, ctx, log_path: Path) -> None:
     _append_log(log_path, "Execute pre-release actions")
     if ctx.get("dry_run"):
@@ -1096,27 +1231,7 @@ def _step_pre_release_actions(release, ctx, log_path: Path) -> None:
         for path in staged_release_fixtures:
             subprocess.run(["git", "reset", "HEAD", str(path)], check=False)
             _append_log(log_path, f"Unstaged release fixture {_format_path(path)}")
-    todo, fixture_path = _ensure_release_todo(
-        release, previous_version=repo_version_before_sync
-    )
-    fixture_display = _format_path(fixture_path)
-    _append_log(log_path, f"Added TODO: {todo.request}")
-    _append_log(log_path, f"Wrote TODO fixture {fixture_display}")
-    subprocess.run(["git", "add", str(fixture_path)], check=True)
-    _append_log(log_path, f"Staged TODO fixture {fixture_display}")
-    fixture_diff = subprocess.run(
-        ["git", "diff", "--cached", "--quiet", "--", str(fixture_path)],
-        check=False,
-    )
-    if fixture_diff.returncode != 0:
-        commit_message = f"chore: add release TODO for {release.package.name}"
-        subprocess.run(["git", "commit", "-m", commit_message], check=True)
-        _append_log(log_path, f"Committed TODO fixture {fixture_display}")
-    else:
-        _append_log(
-            log_path,
-            f"No changes detected for TODO fixture {fixture_display}; skipping commit",
-        )
+    ctx["release_todo_previous_version"] = repo_version_before_sync
     _append_log(log_path, "Pre-release actions complete")
 
 
@@ -1200,6 +1315,7 @@ def _step_promote_build(release, ctx, log_path: Path) -> None:
             )
         PackageRelease.dump_fixture()
         _append_log(log_path, "Updated release fixtures")
+        _record_release_todo(release, ctx, log_path)
     except Exception:
         _clean_repo()
         raise
@@ -1346,12 +1462,29 @@ def _step_publish(release, ctx, log_path: Path) -> None:
         )
     else:
         _append_log(log_path, "Uploading distribution")
-    release_utils.publish(
-        package=release.to_package(),
-        version=release.version,
-        creds=release.to_credentials(),
-        repositories=targets,
-    )
+    publish_warning: release_utils.PostPublishWarning | None = None
+    try:
+        release_utils.publish(
+            package=release.to_package(),
+            version=release.version,
+            creds=release.to_credentials(),
+            repositories=targets,
+        )
+    except release_utils.PostPublishWarning as warning:
+        publish_warning = warning
+
+    if publish_warning is not None:
+        message = str(publish_warning)
+        followups = _dedupe_preserve_order(publish_warning.followups)
+        warning_entries = ctx.setdefault("warnings", [])
+        if not any(entry.get("message") == message for entry in warning_entries):
+            entry: dict[str, object] = {"message": message}
+            if followups:
+                entry["followups"] = followups
+            warning_entries.append(entry)
+        _append_log(log_path, message)
+        for note in followups:
+            _append_log(log_path, f"Follow-up: {note}")
     release.pypi_url = (
         f"https://pypi.org/project/{release.package.name}/{release.version}/"
     )
@@ -1521,6 +1654,7 @@ def rfid_batch(request):
                 "custom_label": t.custom_label,
                 "energy_accounts": list(t.energy_accounts.values_list("id", flat=True)),
                 "external_command": t.external_command,
+                "post_auth_command": t.post_auth_command,
                 "allowed": t.allowed,
                 "color": t.color,
                 "released": t.released,
@@ -1556,6 +1690,11 @@ def rfid_batch(request):
                 external_command = ""
             else:
                 external_command = external_command.strip()
+            post_auth_command = row.get("post_auth_command")
+            if not isinstance(post_auth_command, str):
+                post_auth_command = ""
+            else:
+                post_auth_command = post_auth_command.strip()
 
             tag, _ = RFID.objects.update_or_create(
                 rfid=rfid.upper(),
@@ -1565,6 +1704,7 @@ def rfid_batch(request):
                     "released": released,
                     "custom_label": custom_label,
                     "external_command": external_command,
+                    "post_auth_command": post_auth_command,
                 },
             )
             if energy_accounts:
@@ -1648,6 +1788,12 @@ def release_progress(request, pk: int, action: str):
     else:
         log_dir_warning_message = ctx.get("log_dir_warning_message")
 
+    if "changelog_report_url" not in ctx:
+        try:
+            ctx["changelog_report_url"] = reverse("admin:system-changelog-report")
+        except NoReverseMatch:
+            ctx["changelog_report_url"] = ""
+
     steps = PUBLISH_STEPS
     total_steps = len(steps)
     step_count = ctx.get("step", 0)
@@ -1686,8 +1832,16 @@ def release_progress(request, pk: int, action: str):
             ctx["release_approval"] = "approved"
         if request.GET.get("reject"):
             ctx["release_approval"] = "rejected"
+    resume_requested = bool(request.GET.get("resume"))
+
     if request.GET.get("pause") and ctx.get("started"):
         ctx["paused"] = True
+
+    if resume_requested:
+        if not ctx.get("started"):
+            ctx["started"] = True
+        if ctx.get("paused"):
+            ctx["paused"] = False
     restart_count = 0
     if restart_path.exists():
         try:
@@ -1696,6 +1850,8 @@ def release_progress(request, pk: int, action: str):
             restart_count = 0
     step_count = ctx.get("step", 0)
     step_param = request.GET.get("step")
+    if resume_requested and step_param is None:
+        step_param = str(step_count)
 
     pending_qs = Todo.objects.filter(is_deleted=False, done_on__isnull=True)
     pending_items = list(pending_qs)
@@ -1715,7 +1871,10 @@ def release_progress(request, pk: int, action: str):
         else:
             ctx["todos_ack"] = True
 
-    if pending_items and not ctx.get("todos_ack"):
+    if ctx.get("todos_ack"):
+        ctx.pop("todos_block_logged", None)
+
+    if not ctx.get("todos_ack"):
         ctx["todos"] = [
             {
                 "id": todo.pk,
@@ -1725,8 +1884,10 @@ def release_progress(request, pk: int, action: str):
             }
             for todo in pending_items
         ]
+        ctx["todos_required"] = True
     else:
         ctx.pop("todos", None)
+        ctx.pop("todos_required", None)
 
     log_name = _release_log_name(release.package.name, release.version)
     if ctx.get("log") != log_name:
@@ -1847,7 +2008,9 @@ def release_progress(request, pk: int, action: str):
         and not ctx.get("error")
         else None
     )
-    has_pending_todos = bool(ctx.get("todos") and not ctx.get("todos_ack"))
+    has_pending_todos = bool(
+        ctx.get("todos_required") and not ctx.get("todos_ack")
+    )
     if has_pending_todos:
         next_step = None
     dirty_files = ctx.get("dirty_files")
@@ -1927,6 +2090,14 @@ def release_progress(request, pk: int, action: str):
         )
 
     is_running = ctx.get("started") and not paused and not done and not ctx.get("error")
+    resume_available = (
+        ctx.get("started")
+        and not paused
+        and not done
+        and not ctx.get("error")
+        and step_count < len(steps)
+        and next_step is None
+    )
     can_resume = ctx.get("started") and paused and not done and not ctx.get("error")
     release_manager_owner = manager.owner_display() if manager else ""
     try:
@@ -1964,6 +2135,7 @@ def release_progress(request, pk: int, action: str):
         "cert_log": ctx.get("cert_log"),
         "fixtures": fixtures_summary,
         "todos": todos_display,
+        "changelog_report_url": ctx.get("changelog_report_url", ""),
         "dirty_files": dirty_files,
         "dirty_commit_message": ctx.get("dirty_commit_message", DIRTY_COMMIT_DEFAULT_MESSAGE),
         "dirty_commit_error": ctx.get("dirty_commit_error"),
@@ -1980,9 +2152,11 @@ def release_progress(request, pk: int, action: str):
         "has_release_manager": bool(manager),
         "current_user_admin_url": current_user_admin_url,
         "is_running": is_running,
+        "resume_available": resume_available,
         "can_resume": can_resume,
         "dry_run": dry_run_active,
         "dry_run_toggle_enabled": dry_run_toggle_enabled,
+        "warnings": ctx.get("warnings", []),
     }
     request.session[session_key] = ctx
     if done or ctx.get("error"):
@@ -2180,6 +2354,7 @@ def todo_focus(request, pk: int):
         "focus_auth": focus_auth,
         "next_url": _get_return_url(request),
         "done_url": reverse("todo-done", args=[todo.pk]),
+        "snapshot_url": reverse("todo-snapshot", args=[todo.pk]),
     }
     return render(request, "core/todo_focus.html", context)
 
@@ -2199,3 +2374,67 @@ def todo_done(request, pk: int):
     todo.done_on = timezone.now()
     todo.save(update_fields=["done_on"])
     return redirect(redirect_to)
+
+
+@staff_member_required
+@require_POST
+def todo_snapshot(request, pk: int):
+    todo = get_object_or_404(Todo, pk=pk, is_deleted=False)
+    if todo.done_on:
+        return JsonResponse({"detail": _("This TODO has already been completed.")}, status=400)
+
+    try:
+        payload = json.loads(request.body.decode("utf-8") or "{}")
+    except json.JSONDecodeError:
+        return JsonResponse({"detail": _("Invalid JSON payload.")}, status=400)
+
+    image_data = payload.get("image", "") if isinstance(payload, dict) else ""
+    if not isinstance(image_data, str) or not image_data.startswith("data:image/png;base64,"):
+        return JsonResponse({"detail": _("A PNG data URL is required.")}, status=400)
+
+    try:
+        encoded = image_data.split(",", 1)[1]
+    except IndexError:
+        return JsonResponse({"detail": _("Screenshot data is incomplete.")}, status=400)
+
+    try:
+        image_bytes = base64.b64decode(encoded, validate=True)
+    except (ValueError, binascii.Error):
+        return JsonResponse({"detail": _("Unable to decode screenshot data.")}, status=400)
+
+    if not image_bytes:
+        return JsonResponse({"detail": _("Screenshot data is empty.")}, status=400)
+
+    max_size = 5 * 1024 * 1024
+    if len(image_bytes) > max_size:
+        return JsonResponse({"detail": _("Screenshot is too large to store.")}, status=400)
+
+    relative_path = Path("screenshots") / f"todo-{todo.pk}-{uuid.uuid4().hex}.png"
+    full_path = settings.LOG_DIR / relative_path
+    full_path.parent.mkdir(parents=True, exist_ok=True)
+    with full_path.open("wb") as fh:
+        fh.write(image_bytes)
+
+    primary_text = strip_tags(todo.request or "").strip()
+    details_text = strip_tags(todo.request_details or "").strip()
+    alt_parts = [part for part in (primary_text, details_text) if part]
+    if alt_parts:
+        alt_text = " — ".join(alt_parts)
+    else:
+        alt_text = _("TODO %(id)s snapshot") % {"id": todo.pk}
+
+    sample = save_screenshot(
+        relative_path,
+        method="TODO_QA",
+        content=alt_text,
+        user=request.user if request.user.is_authenticated else None,
+    )
+
+    if sample is None:
+        try:
+            full_path.unlink()
+        except FileNotFoundError:
+            pass
+        return JsonResponse({"detail": _("Duplicate snapshot ignored.")})
+
+    return JsonResponse({"detail": _("Snapshot saved."), "sample": str(sample.pk)})

nodes/admin.py

@@ -1217,6 +1217,11 @@ class NodeFeatureAdmin(EntityModelAdmin):
                 self.admin_site.admin_view(self.celery_report),
                 name="nodes_nodefeature_celery_report",
             ),
+            path(
+                "view-waveform/",
+                self.admin_site.admin_view(self.view_waveform),
+                name="nodes_nodefeature_view_waveform",
+            ),
             path(
                 "take-screenshot/",
                 self.admin_site.admin_view(self.take_screenshot),
@@ -1291,6 +1296,24 @@ class NodeFeatureAdmin(EntityModelAdmin):
             return None
         return feature
 
+    def view_waveform(self, request):
+        feature = self._ensure_feature_enabled(
+            request, "audio-capture", "View Waveform"
+        )
+        if not feature:
+            return redirect("..")
+
+        context = {
+            **self.admin_site.each_context(request),
+            "title": _("Audio Capture Waveform"),
+            "feature": feature,
+        }
+        return TemplateResponse(
+            request,
+            "admin/nodes/nodefeature/view_waveform.html",
+            context,
+        )
+
     def take_screenshot(self, request):
         feature = self._ensure_feature_enabled(
             request, "screenshot-poll", "Take Screenshot"
@@ -1542,7 +1565,7 @@ class NetMessageAdmin(EntityModelAdmin):
     search_fields = ("subject", "body")
     list_filter = ("complete", "filter_node_role", "filter_current_relation")
     ordering = ("-created",)
-    readonly_fields = ("complete",)
+    readonly_fields = ("complete", "confirmed_peers")
     actions = ["send_messages"]
     fieldsets = (
         (None, {"fields": ("subject", "body")}),
@@ -1567,6 +1590,7 @@ class NetMessageAdmin(EntityModelAdmin):
                     "node_origin",
                     "target_limit",
                     "propagated_to",
+                    "confirmed_peers",
                     "complete",
                 )
             },