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

core/system.py

@@ -10,17 +10,28 @@ 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.html import format_html, format_html_join
+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 core.release import (
+    _git_authentication_missing,
+    _git_remote_url,
+    _manager_git_credentials,
+    _remote_with_credentials,
+)
+from core.tasks import check_github_updates
 from utils import revision
 
 
@@ -29,6 +40,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 +55,246 @@ 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")
+
+
+def _format_git_command_output(
+    command: list[str], result: subprocess.CompletedProcess[str]
+) -> str:
+    """Return a readable summary of a git command execution."""
+
+    command_display = "$ " + " ".join(command)
+    message_parts = []
+    if result.stdout:
+        message_parts.append(result.stdout.strip())
+    if result.stderr:
+        message_parts.append(result.stderr.strip())
+    if result.returncode != 0:
+        message_parts.append(f"[exit status {result.returncode}]")
+    if message_parts:
+        return command_display + "\n" + "\n".join(part for part in message_parts if part)
+    return command_display
+
+
+def _git_status() -> str:
+    """Return the repository status after attempting to commit."""
+
+    status_result = subprocess.run(
+        ["git", "status", "--short", "--branch"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    stdout = status_result.stdout.strip()
+    stderr = status_result.stderr.strip()
+    if stdout and stderr:
+        return stdout + "\n" + stderr
+    return stdout or stderr
+
+
+def _commit_changelog() -> tuple[bool, str, str]:
+    """Stage, commit, and push the changelog file."""
+
+    def _retry_push_with_release_credentials(
+        command: list[str],
+        result: subprocess.CompletedProcess[str],
+    ) -> bool:
+        exc = subprocess.CalledProcessError(
+            result.returncode,
+            command,
+            output=result.stdout,
+            stderr=result.stderr,
+        )
+        if not _git_authentication_missing(exc):
+            return False
+
+        creds = _manager_git_credentials()
+        if not creds or not creds.has_auth():
+            return False
+
+        remote_url = _git_remote_url("origin")
+        if not remote_url:
+            return False
+
+        authed_url = _remote_with_credentials(remote_url, creds)
+        if not authed_url:
+            return False
+
+        retry_command = ["git", "push", authed_url]
+        retry_result = subprocess.run(
+            retry_command,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        formatted_retry = _format_git_command_output(retry_command, retry_result)
+        if formatted_retry:
+            outputs.append(formatted_retry)
+        logger.info(
+            "Executed %s with exit code %s",
+            retry_command,
+            retry_result.returncode,
+        )
+        return retry_result.returncode == 0
+
+    git_commands: list[list[str]] = [
+        ["git", "add", "CHANGELOG.rst"],
+        [
+            "git",
+            "commit",
+            "-m",
+            "chore: update changelog",
+            "--",
+            "CHANGELOG.rst",
+        ],
+        ["git", "push"],
+    ]
+    outputs: list[str] = []
+    success = True
+
+    for command in git_commands:
+        result = subprocess.run(
+            command, capture_output=True, text=True, check=False
+        )
+        formatted = _format_git_command_output(command, result)
+        outputs.append(formatted)
+        logger.info("Executed %s with exit code %s", command, result.returncode)
+        if result.returncode != 0:
+            if command[:2] == ["git", "push"] and _retry_push_with_release_credentials(
+                command, result
+            ):
+                continue
+            success = False
+            break
+
+    command_output = "\n\n".join(output for output in outputs if output)
+    repo_status = _git_status()
+    return success, command_output, repo_status
+
+
 @dataclass(frozen=True)
 class SystemField:
     """Metadata describing a single entry on the system admin page."""
@@ -584,7 +838,14 @@ def _gather_info() -> dict:
     info["service"] = service_file.read_text().strip() if service_file.exists() else ""
 
     mode_file = lock_dir / "nginx_mode.lck"
-    mode = mode_file.read_text().strip() if mode_file.exists() else "internal"
+    if mode_file.exists():
+        try:
+            raw_mode = mode_file.read_text().strip()
+        except OSError:
+            raw_mode = ""
+    else:
+        raw_mode = ""
+    mode = raw_mode.lower() or "internal"
     info["mode"] = mode
     default_port = 8000 if mode == "public" else 8888
     detected_port: int | None = None
@@ -721,6 +982,99 @@ 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."),
+                    )
+        elif action == "commit":
+            success, command_output, repo_status = _commit_changelog()
+            details: list[str] = []
+            if command_output:
+                details.append(
+                    format_html(
+                        "<div class=\"changelog-git-output\"><strong>{}</strong><pre>{}</pre></div>",
+                        _("Command log"),
+                        command_output,
+                    )
+                )
+            if repo_status:
+                details.append(
+                    format_html(
+                        "<div class=\"changelog-git-status\"><strong>{}</strong><pre>{}</pre></div>",
+                        _("Repository status"),
+                        repo_status,
+                    )
+                )
+            details_html = (
+                format_html_join("", "{}", ((detail,) for detail in details))
+                if details
+                else ""
+            )
+            if success:
+                base_message = _("Committed the changelog and pushed to the current branch.")
+                messages.success(request, format_html("{}{}", base_message, details_html))
+            else:
+                base_message = _("Unable to commit the changelog.")
+                messages.error(request, format_html("{}{}", base_message, details_html))
+        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(
@@ -732,6 +1086,49 @@ def _system_upgrade_report_view(request):
     return TemplateResponse(request, "admin/system_upgrade_report.html", context)
 
 
+def _trigger_upgrade_check() -> bool:
+    """Return ``True`` when the upgrade check was queued asynchronously."""
+
+    try:
+        check_github_updates.delay()
+    except Exception:
+        logger.exception("Failed to enqueue upgrade check; running synchronously instead")
+        check_github_updates()
+        return False
+    return True
+
+
+def _system_trigger_upgrade_check_view(request):
+    if request.method != "POST":
+        return HttpResponseRedirect(reverse("admin:system-upgrade-report"))
+
+    try:
+        queued = _trigger_upgrade_check()
+    except Exception as exc:  # pragma: no cover - unexpected failure
+        logger.exception("Unable to trigger upgrade check")
+        messages.error(
+            request,
+            _("Unable to trigger an upgrade check: %(error)s")
+            % {"error": str(exc)},
+        )
+    else:
+        if queued:
+            messages.success(
+                request,
+                _("Upgrade check requested. The task will run shortly."),
+            )
+        else:
+            messages.success(
+                request,
+                _(
+                    "Upgrade check started locally. Review the auto-upgrade log for"
+                    " progress."
+                ),
+            )
+
+    return HttpResponseRedirect(reverse("admin:system-upgrade-report"))
+
+
 def patch_admin_system_view() -> None:
     """Add custom admin view for system information."""
     original_get_urls = admin.site.get_urls
@@ -740,11 +1137,21 @@ 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),
                 name="system-upgrade-report",
             ),
+            path(
+                "system/upgrade-report/run-check/",
+                admin.site.admin_view(_system_trigger_upgrade_check_view),
+                name="system-upgrade-run-check",
+            ),
         ]
         return custom + urls
 

core/tasks.py

@@ -132,11 +132,15 @@ def check_github_updates() -> None:
     mode = "version"
     if mode_file.exists():
         try:
-            mode = mode_file.read_text().strip() or "version"
+            raw_mode = mode_file.read_text().strip()
         except (OSError, UnicodeDecodeError):
             logger.warning(
                 "Failed to read auto-upgrade mode lockfile", exc_info=True
             )
+        else:
+            cleaned_mode = raw_mode.lower()
+            if cleaned_mode:
+                mode = cleaned_mode
 
     branch = "main"
     subprocess.run(["git", "fetch", "origin", branch], cwd=base_dir, check=True)

core/test_system_info.py

@@ -55,6 +55,22 @@ class SystemInfoScreenModeTests(SimpleTestCase):
                 lock_dir.rmdir()
 
 
+class SystemInfoModeTests(SimpleTestCase):
+    def test_public_mode_case_insensitive(self):
+        lock_dir = Path(settings.BASE_DIR) / "locks"
+        lock_dir.mkdir(exist_ok=True)
+        lock_file = lock_dir / "nginx_mode.lck"
+        lock_file.write_text("PUBLIC", encoding="utf-8")
+        try:
+            info = _gather_info()
+            self.assertEqual(info["mode"], "public")
+            self.assertEqual(info["port"], 8000)
+        finally:
+            lock_file.unlink()
+            if not any(lock_dir.iterdir()):
+                lock_dir.rmdir()
+
+
 class SystemInfoRevisionTests(SimpleTestCase):
     @patch("core.system.revision.get_revision", return_value="abcdef1234567890")
     def test_includes_full_revision(self, mock_revision):