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

core/system.py

@@ -10,17 +10,20 @@ import re
 import socket
 import subprocess
 import shutil
+import logging
 from typing import Callable, Iterable, Optional
 
 from django.conf import settings
-from django.contrib import admin
+from django.contrib import admin, messages
 from django.template.response import TemplateResponse
-from django.urls import path
+from django.http import HttpResponseRedirect
+from django.urls import path, reverse
 from django.utils import timezone
 from django.utils.formats import date_format
-from django.utils.translation import gettext_lazy as _
+from django.utils.translation import gettext_lazy as _, ngettext
 
 from core.auto_upgrade import AUTO_UPGRADE_TASK_NAME, AUTO_UPGRADE_TASK_PATH
+from core import changelog as changelog_utils
 from utils import revision
 
 
@@ -29,6 +32,9 @@ AUTO_UPGRADE_SKIP_LOCK_NAME = "auto_upgrade_skip_revisions.lck"
 AUTO_UPGRADE_LOG_NAME = "auto-upgrade.log"
 
 
+logger = logging.getLogger(__name__)
+
+
 def _auto_upgrade_mode_file(base_dir: Path) -> Path:
     return base_dir / "locks" / AUTO_UPGRADE_LOCK_NAME
 
@@ -41,6 +47,132 @@ def _auto_upgrade_log_file(base_dir: Path) -> Path:
     return base_dir / "logs" / AUTO_UPGRADE_LOG_NAME
 
 
+def _open_changelog_entries() -> list[dict[str, str]]:
+    """Return changelog entries that are not yet part of a tagged release."""
+
+    changelog_path = Path("CHANGELOG.rst")
+    try:
+        text = changelog_path.read_text(encoding="utf-8")
+    except FileNotFoundError:
+        return []
+    except OSError:
+        return []
+
+    collecting = False
+    entries: list[dict[str, str]] = []
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if not collecting:
+            if line == "Unreleased":
+                collecting = True
+            continue
+
+        if not line:
+            if entries:
+                break
+            continue
+
+        if set(line) == {"-"}:
+            # Underline immediately following the section heading.
+            continue
+
+        if not line.startswith("- "):
+            break
+
+        trimmed = line[2:].strip()
+        if not trimmed:
+            continue
+        parts = trimmed.split(" ", 1)
+        sha = parts[0]
+        message = parts[1] if len(parts) > 1 else ""
+        entries.append({"sha": sha, "message": message})
+
+    return entries
+
+
+def _exclude_changelog_entries(shas: Iterable[str]) -> int:
+    """Remove entries matching ``shas`` from the changelog.
+
+    Returns the number of entries removed. Only entries within the
+    ``Unreleased`` section are considered.
+    """
+
+    normalized_shas = {sha.strip() for sha in shas if sha and sha.strip()}
+    if not normalized_shas:
+        return 0
+
+    changelog_path = Path("CHANGELOG.rst")
+    try:
+        text = changelog_path.read_text(encoding="utf-8")
+    except (FileNotFoundError, OSError):
+        return 0
+
+    lines = text.splitlines(keepends=True)
+    new_lines: list[str] = []
+    collecting = False
+    removed = 0
+
+    for raw_line in lines:
+        stripped = raw_line.strip()
+
+        if not collecting:
+            new_lines.append(raw_line)
+            if stripped == "Unreleased":
+                collecting = True
+            continue
+
+        if not stripped:
+            new_lines.append(raw_line)
+            continue
+
+        if set(stripped) == {"-"}:
+            new_lines.append(raw_line)
+            continue
+
+        if not stripped.startswith("- "):
+            new_lines.append(raw_line)
+            collecting = False
+            continue
+
+        trimmed = stripped[2:].strip()
+        if not trimmed:
+            new_lines.append(raw_line)
+            continue
+
+        sha = trimmed.split(" ", 1)[0]
+        if sha in normalized_shas:
+            removed += 1
+            normalized_shas.remove(sha)
+            continue
+
+        new_lines.append(raw_line)
+
+    if removed:
+        new_text = "".join(new_lines)
+        if not new_text.endswith("\n"):
+            new_text += "\n"
+        changelog_path.write_text(new_text, encoding="utf-8")
+
+    return removed
+
+
+def _regenerate_changelog() -> None:
+    """Rebuild the changelog file using recent git commits."""
+
+    changelog_path = Path("CHANGELOG.rst")
+    previous_text = (
+        changelog_path.read_text(encoding="utf-8") if changelog_path.exists() else None
+    )
+    range_spec = changelog_utils.determine_range_spec()
+    sections = changelog_utils.collect_sections(
+        range_spec=range_spec, previous_text=previous_text
+    )
+    content = changelog_utils.render_changelog(sections)
+    if not content.endswith("\n"):
+        content += "\n"
+    changelog_path.write_text(content, encoding="utf-8")
+
+
 @dataclass(frozen=True)
 class SystemField:
     """Metadata describing a single entry on the system admin page."""
@@ -721,6 +853,69 @@ def _system_view(request):
     return TemplateResponse(request, "admin/system.html", context)
 
 
+def _system_changelog_report_view(request):
+    if request.method == "POST":
+        action = request.POST.get("action")
+        if action == "exclude":
+            selected_shas = request.POST.getlist("selected_shas")
+            removed = _exclude_changelog_entries(selected_shas)
+            if removed:
+                messages.success(
+                    request,
+                    ngettext(
+                        "Excluded %(count)d changelog entry.",
+                        "Excluded %(count)d changelog entries.",
+                        removed,
+                    )
+                    % {"count": removed},
+                )
+            else:
+                if selected_shas:
+                    messages.info(
+                        request,
+                        _(
+                            "The selected changelog entries were not found or have already been excluded."
+                        ),
+                    )
+                else:
+                    messages.info(
+                        request,
+                        _("Select at least one changelog entry to exclude."),
+                    )
+        else:
+            try:
+                _regenerate_changelog()
+            except subprocess.CalledProcessError as exc:
+                logger.exception("Changelog regeneration failed")
+                messages.error(
+                    request,
+                    _("Unable to recalculate the changelog: %(error)s")
+                    % {"error": exc.stderr.strip() if exc.stderr else str(exc)},
+                )
+            except Exception as exc:  # pragma: no cover - unexpected failure
+                logger.exception("Unexpected error while regenerating changelog")
+                messages.error(
+                    request,
+                    _("Unable to recalculate the changelog: %(error)s")
+                    % {"error": str(exc)},
+                )
+            else:
+                messages.success(
+                    request,
+                    _("Successfully recalculated the changelog from recent commits."),
+                )
+        return HttpResponseRedirect(reverse("admin:system-changelog-report"))
+
+    context = admin.site.each_context(request)
+    context.update(
+        {
+            "title": _("Changelog Report"),
+            "open_changelog_entries": _open_changelog_entries(),
+        }
+    )
+    return TemplateResponse(request, "admin/system_changelog_report.html", context)
+
+
 def _system_upgrade_report_view(request):
     context = admin.site.each_context(request)
     context.update(
@@ -740,6 +935,11 @@ def patch_admin_system_view() -> None:
         urls = original_get_urls()
         custom = [
             path("system/", admin.site.admin_view(_system_view), name="system"),
+            path(
+                "system/changelog-report/",
+                admin.site.admin_view(_system_changelog_report_view),
+                name="system-changelog-report",
+            ),
             path(
                 "system/upgrade-report/",
                 admin.site.admin_view(_system_upgrade_report_view),

core/tests.py

@@ -1051,6 +1051,79 @@ class ReleaseProcessTests(TestCase):
         requests_get.assert_called_once()
         sync_main.assert_called_once_with(Path("rel.log"))
 
+    @mock.patch("core.views.release_utils.network_available", return_value=False)
+    @mock.patch("core.views._collect_dirty_files")
+    @mock.patch("core.views._sync_with_origin_main")
+    @mock.patch("core.views.subprocess.run")
+    @mock.patch("core.views.release_utils._git_clean", return_value=False)
+    def test_step_check_commits_release_prep_changes(
+        self,
+        git_clean,
+        subprocess_run,
+        sync_main,
+        collect_dirty,
+        network_available,
+    ):
+        fixture_path = next(Path("core/fixtures").glob("releases__*.json"))
+        collect_dirty.return_value = [
+            {
+                "path": str(fixture_path),
+                "status": "M",
+                "status_label": "Modified",
+            },
+            {"path": "CHANGELOG.rst", "status": "M", "status_label": "Modified"},
+        ]
+        subprocess_run.return_value = mock.Mock(returncode=0, stdout="", stderr="")
+
+        ctx: dict[str, object] = {}
+        _step_check_version(self.release, ctx, Path("rel.log"))
+
+        add_call = mock.call(
+            ["git", "add", str(fixture_path), "CHANGELOG.rst"],
+            check=True,
+        )
+        commit_call = mock.call(
+            [
+                "git",
+                "commit",
+                "-m",
+                "chore: sync release fixtures and changelog",
+            ],
+            check=True,
+        )
+        self.assertIn(add_call, subprocess_run.call_args_list)
+        self.assertIn(commit_call, subprocess_run.call_args_list)
+        self.assertNotIn("dirty_files", ctx)
+
+    @mock.patch("core.views.release_utils.network_available", return_value=False)
+    @mock.patch("core.views._collect_dirty_files")
+    @mock.patch("core.views._sync_with_origin_main")
+    @mock.patch("core.views.subprocess.run")
+    @mock.patch("core.views.release_utils._git_clean", return_value=False)
+    def test_step_check_commits_changelog_only(
+        self,
+        git_clean,
+        subprocess_run,
+        sync_main,
+        collect_dirty,
+        network_available,
+    ):
+        collect_dirty.return_value = [
+            {"path": "CHANGELOG.rst", "status": "M", "status_label": "Modified"}
+        ]
+        subprocess_run.return_value = mock.Mock(returncode=0, stdout="", stderr="")
+
+        ctx: dict[str, object] = {}
+        _step_check_version(self.release, ctx, Path("rel.log"))
+
+        subprocess_run.assert_any_call(
+            ["git", "add", "CHANGELOG.rst"], check=True
+        )
+        subprocess_run.assert_any_call(
+            ["git", "commit", "-m", "docs: refresh changelog"], check=True
+        )
+        self.assertNotIn("dirty_files", ctx)
+
     @mock.patch("core.models.PackageRelease.dump_fixture")
     def test_save_does_not_dump_fixture(self, dump):
         self.release.pypi_url = "https://example.com"

core/views.py

@@ -859,7 +859,12 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
             for f in files
             if "fixtures" in Path(f).parts and Path(f).suffix == ".json"
         ]
-        if files and len(fixture_files) == len(files):
+        changelog_dirty = "CHANGELOG.rst" in files
+        allowed_dirty_files = set(fixture_files)
+        if changelog_dirty:
+            allowed_dirty_files.add("CHANGELOG.rst")
+
+        if files and len(allowed_dirty_files) == len(files):
             summary = []
             for f in fixture_files:
                 path = Path(f)
@@ -887,15 +892,36 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
                 summary.append({"path": f, "count": count, "models": models})
 
             ctx["fixtures"] = summary
+            commit_paths = [*fixture_files]
+            if changelog_dirty:
+                commit_paths.append("CHANGELOG.rst")
+
+            log_fragments = []
+            if fixture_files:
+                log_fragments.append(
+                    "fixtures " + ", ".join(fixture_files)
+                )
+            if changelog_dirty:
+                log_fragments.append("CHANGELOG.rst")
+            details = ", ".join(log_fragments) if log_fragments else "changes"
             _append_log(
                 log_path,
-                "Committing fixture changes: " + ", ".join(fixture_files),
+                f"Committing release prep changes: {details}",
             )
-            subprocess.run(["git", "add", *fixture_files], check=True)
-            subprocess.run(
-                ["git", "commit", "-m", "chore: update fixtures"], check=True
+            subprocess.run(["git", "add", *commit_paths], check=True)
+
+            if changelog_dirty and fixture_files:
+                commit_message = "chore: sync release fixtures and changelog"
+            elif changelog_dirty:
+                commit_message = "docs: refresh changelog"
+            else:
+                commit_message = "chore: update fixtures"
+
+            subprocess.run(["git", "commit", "-m", commit_message], check=True)
+            _append_log(
+                log_path,
+                f"Release prep changes committed ({commit_message})",
             )
-            _append_log(log_path, "Fixture changes committed")
             ctx.pop("dirty_files", None)
             ctx.pop("dirty_commit_error", None)
             retry_sync = True

nodes/models.py

@@ -16,7 +16,6 @@ import base64
 from django.utils import timezone
 from django.utils.text import slugify
 from django.conf import settings
-from django.contrib.sites.models import Site
 from datetime import timedelta
 import uuid
 import os
@@ -344,7 +343,6 @@ class Node(Entity):
             if terminal:
                 node.role = terminal
                 node.save(update_fields=["role"])
-        Site.objects.get_or_create(domain=hostname, defaults={"name": "host"})
         node.ensure_keys()
         node.notify_peers_of_update()
         return node, created
@@ -745,8 +743,10 @@ class Node(Entity):
     def sync_feature_tasks(self):
         clipboard_enabled = self.has_feature("clipboard-poll")
         screenshot_enabled = self.has_feature("screenshot-poll")
+        celery_enabled = self.is_local and self.has_feature("celery-queue")
         self._sync_clipboard_task(clipboard_enabled)
         self._sync_screenshot_task(screenshot_enabled)
+        self._sync_landing_lead_task(celery_enabled)
 
     def _sync_clipboard_task(self, enabled: bool):
         from django_celery_beat.models import IntervalSchedule, PeriodicTask
@@ -792,6 +792,33 @@ class Node(Entity):
         else:
             PeriodicTask.objects.filter(name=task_name).delete()
 
+    def _sync_landing_lead_task(self, enabled: bool):
+        if not self.is_local:
+            return
+
+        from django_celery_beat.models import CrontabSchedule, PeriodicTask
+
+        task_name = "pages_purge_landing_leads"
+        if enabled:
+            schedule, _ = CrontabSchedule.objects.get_or_create(
+                minute="0",
+                hour="3",
+                day_of_week="*",
+                day_of_month="*",
+                month_of_year="*",
+            )
+            PeriodicTask.objects.update_or_create(
+                name=task_name,
+                defaults={
+                    "crontab": schedule,
+                    "interval": None,
+                    "task": "pages.tasks.purge_expired_landing_leads",
+                    "enabled": True,
+                },
+            )
+        else:
+            PeriodicTask.objects.filter(name=task_name).delete()
+
     def send_mail(
         self,
         subject: str,

nodes/tests.py

@@ -35,7 +35,6 @@ from django.urls import reverse
 from django.contrib.auth import get_user_model
 from django.contrib import admin
 from django.contrib.auth.models import Permission
-from django.contrib.sites.models import Site
 from django_celery_beat.models import IntervalSchedule, PeriodicTask
 from django.conf import settings
 from django.utils import timezone
@@ -1271,6 +1270,29 @@ class NodeRegisterCurrentTests(TestCase):
         NodeFeatureAssignment.objects.filter(node=node, feature=feature).delete()
         self.assertFalse(PeriodicTask.objects.filter(name=task_name).exists())
 
+    def test_landing_lead_purge_task_syncs_with_celery_feature(self):
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="celery-queue", defaults={"display": "Celery Queue"}
+        )
+        node, _ = Node.objects.update_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={
+                "hostname": socket.gethostname(),
+                "address": "127.0.0.1",
+                "port": 9300,
+                "base_path": settings.BASE_DIR,
+            },
+        )
+        PeriodicTask.objects.filter(name="pages_purge_landing_leads").delete()
+        NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+        self.assertTrue(
+            PeriodicTask.objects.filter(name="pages_purge_landing_leads").exists()
+        )
+        NodeFeatureAssignment.objects.filter(node=node, feature=feature).delete()
+        self.assertFalse(
+            PeriodicTask.objects.filter(name="pages_purge_landing_leads").exists()
+        )
+
 
 class CheckRegistrationReadyCommandTests(TestCase):
     def test_command_completes_successfully(self):
@@ -1357,8 +1379,6 @@ class NodeAdminTests(TestCase):
         self.assertTrue(priv.exists())
         self.assertTrue(pub.exists())
         self.assertTrue(node.public_key)
-        self.assertTrue(Site.objects.filter(domain=hostname, name="host").exists())
-
     def test_register_current_updates_existing_node(self):
         hostname = socket.gethostname()
         Node.objects.create(

pages/admin.py

@@ -18,11 +18,13 @@ import ipaddress
 from django.apps import apps as django_apps
 from django.conf import settings
 from django.utils.translation import gettext_lazy as _, ngettext
+from django.core.management import CommandError, call_command
 
 from nodes.models import Node
 from nodes.utils import capture_screenshot, save_screenshot
 
 from .forms import UserManualAdminForm
+from .utils import landing_leads_supported
 
 from .models import (
     SiteBadge,
@@ -107,6 +109,49 @@ class SiteAdmin(DjangoSiteAdmin):
                     messages.INFO,
                 )
 
+    def _reload_site_fixtures(self, request):
+        fixtures_dir = Path(settings.BASE_DIR) / "core" / "fixtures"
+        fixture_paths = sorted(fixtures_dir.glob("references__00_site_*.json"))
+        sigil_fixture = fixtures_dir / "sigil_roots__site.json"
+        if sigil_fixture.exists():
+            fixture_paths.append(sigil_fixture)
+
+        if not fixture_paths:
+            self.message_user(request, _("No site fixtures found."), messages.WARNING)
+            return None
+
+        loaded = 0
+        for path in fixture_paths:
+            try:
+                call_command("loaddata", str(path), verbosity=0)
+            except CommandError as exc:
+                self.message_user(
+                    request,
+                    _("%(fixture)s: %(error)s")
+                    % {"fixture": path.name, "error": exc},
+                    messages.ERROR,
+                )
+            else:
+                loaded += 1
+
+        if loaded:
+            message = ngettext(
+                "Reloaded %(count)d site fixture.",
+                "Reloaded %(count)d site fixtures.",
+                loaded,
+            ) % {"count": loaded}
+            self.message_user(request, message, messages.SUCCESS)
+
+        return None
+
+    def reload_site_fixtures(self, request):
+        if request.method != "POST":
+            return redirect("..")
+
+        self._reload_site_fixtures(request)
+
+        return redirect("..")
+
     def get_urls(self):
         urls = super().get_urls()
         custom = [
@@ -114,7 +159,12 @@ class SiteAdmin(DjangoSiteAdmin):
                 "register-current/",
                 self.admin_site.admin_view(self.register_current),
                 name="pages_siteproxy_register_current",
-            )
+            ),
+            path(
+                "reload-site-fixtures/",
+                self.admin_site.admin_view(self.reload_site_fixtures),
+                name="pages_siteproxy_reload_site_fixtures",
+            ),
         ]
         return custom + urls
 
@@ -237,6 +287,17 @@ class LandingLeadAdmin(EntityModelAdmin):
     ordering = ("-created_on",)
     date_hierarchy = "created_on"
 
+    def changelist_view(self, request, extra_context=None):
+        if not landing_leads_supported():
+            self.message_user(
+                request,
+                _(
+                    "Landing leads are not being recorded because Celery is not running on this node."
+                ),
+                messages.WARNING,
+            )
+        return super().changelist_view(request, extra_context=extra_context)
+
     @admin.display(description=_("Landing"), ordering="landing__label")
     def landing_label(self, obj):
         return obj.landing.label

pages/middleware.py

@@ -10,6 +10,7 @@ from django.conf import settings
 from django.urls import Resolver404, resolve
 
 from .models import Landing, LandingLead, ViewHistory
+from .utils import landing_leads_supported
 
 
 logger = logging.getLogger(__name__)
@@ -125,6 +126,9 @@ class ViewHistoryMiddleware:
         if request.method.upper() != "GET":
             return
 
+        if not landing_leads_supported():
+            return
+
         referer = request.META.get("HTTP_REFERER", "") or ""
         user_agent = request.META.get("HTTP_USER_AGENT", "") or ""
         ip_address = self._extract_client_ip(request) or None

pages/models.py

@@ -1,3 +1,6 @@
+import logging
+from pathlib import Path
+
 from django.db import models
 from django.db.models import Q
 from core.entity import Entity
@@ -15,6 +18,10 @@ from django.core.validators import MaxLengthValidator, MaxValueValidator, MinVal
 from django.core.exceptions import ValidationError
 
 from core import github_issues
+from .tasks import create_user_story_github_issue
+
+
+logger = logging.getLogger(__name__)
 
 
 class ApplicationManager(models.Manager):
@@ -599,6 +606,35 @@ from django.db.models.signals import post_save
 from django.dispatch import receiver
 
 
+def _celery_lock_path() -> Path:
+    return Path(settings.BASE_DIR) / "locks" / "celery.lck"
+
+
+def _is_celery_enabled() -> bool:
+    return _celery_lock_path().exists()
+
+
+@receiver(post_save, sender=UserStory)
+def _queue_low_rating_user_story_issue(
+    sender, instance: UserStory, created: bool, raw: bool, **kwargs
+) -> None:
+    if raw or not created:
+        return
+    if instance.rating >= 5:
+        return
+    if instance.github_issue_url:
+        return
+    if not _is_celery_enabled():
+        return
+
+    try:
+        create_user_story_github_issue.delay(instance.pk)
+    except Exception:  # pragma: no cover - logging only
+        logger.exception(
+            "Failed to enqueue GitHub issue creation for user story %s", instance.pk
+        )
+
+
 @receiver(post_save, sender=Module)
 def _create_landings(
     sender, instance, created, raw, **kwargs