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

core/notifications.py

@@ -39,7 +39,7 @@ class NotificationManager:
         self.lock_file.parent.mkdir(parents=True, exist_ok=True)
         # ``plyer`` is only available on Windows and can fail when used in
         # a non-interactive environment (e.g. service or CI).
-        # Any failure will fallback to logging quietly.
+        # Any failure will fall back to logging quietly.
 
     def _write_lock_file(self, subject: str, body: str) -> None:
         self.lock_file.write_text(f"{subject}\n{body}\n", encoding="utf-8")

core/reference_utils.py

@@ -70,17 +70,16 @@ def filter_visible_references(
         required_sites = {current_site.pk for current_site in ref.sites.all()}
 
         if required_roles or required_features or required_sites:
-            allowed = False
-            if required_roles and node_role_id and node_role_id in required_roles:
-                allowed = True
-            elif (
-                required_features
-                and node_active_feature_ids
-                and node_active_feature_ids.intersection(required_features)
-            ):
-                allowed = True
-            elif required_sites and site_id and site_id in required_sites:
-                allowed = True
+            allowed = True
+            if required_roles:
+                allowed = bool(node_role_id and node_role_id in required_roles)
+            if allowed and required_features:
+                allowed = bool(
+                    node_active_feature_ids
+                    and node_active_feature_ids.intersection(required_features)
+                )
+            if allowed and required_sites:
+                allowed = bool(site_id and site_id in required_sites)
 
             if not allowed:
                 continue

core/release.py

@@ -114,6 +114,21 @@ class ReleaseError(Exception):
     pass
 
 
+class PostPublishWarning(ReleaseError):
+    """Raised when distribution uploads succeed but post-publish tasks need attention."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        uploaded: Sequence[str],
+        followups: Optional[Sequence[str]] = None,
+    ) -> None:
+        super().__init__(message)
+        self.uploaded = list(uploaded)
+        self.followups = list(followups or [])
+
+
 class TestsFailed(ReleaseError):
     """Raised when the test suite fails.
 
@@ -505,11 +520,6 @@ def build(
         if not version_path.exists():
             raise ReleaseError("VERSION file not found")
         version = version_path.read_text().strip()
-        if bump:
-            major, minor, patch = map(int, version.split("."))
-            patch += 1
-            version = f"{major}.{minor}.{patch}"
-            version_path.write_text(version + "\n")
     else:
         # Ensure the VERSION file reflects the provided release version
         if version_path.parent != Path("."):
@@ -711,8 +721,46 @@ def publish(
         uploaded.append(target.name)
 
     tag_name = f"v{version}"
-    _run(["git", "tag", tag_name])
-    _push_tag(tag_name, package)
+    try:
+        _run(["git", "tag", tag_name])
+    except subprocess.CalledProcessError as exc:
+        details = _format_subprocess_error(exc)
+        if uploaded:
+            uploads = ", ".join(uploaded)
+            if details:
+                message = (
+                    f"Upload to {uploads} completed, but creating git tag {tag_name} failed: {details}"
+                )
+            else:
+                message = (
+                    f"Upload to {uploads} completed, but creating git tag {tag_name} failed."
+                )
+            followups = [f"Create and push git tag {tag_name} manually once the repository is ready."]
+            raise PostPublishWarning(
+                message,
+                uploaded=uploaded,
+                followups=followups,
+            ) from exc
+        raise ReleaseError(
+            f"Failed to create git tag {tag_name}: {details or exc}"
+        ) from exc
+
+    try:
+        _push_tag(tag_name, package)
+    except ReleaseError as exc:
+        if uploaded:
+            uploads = ", ".join(uploaded)
+            message = f"Upload to {uploads} completed, but {exc}"
+            followups = [
+                f"Push git tag {tag_name} to origin after resolving the reported issue."
+            ]
+            warning = PostPublishWarning(
+                message,
+                uploaded=uploaded,
+                followups=followups,
+            )
+            raise warning from exc
+        raise
     return uploaded
 
 

core/sigil_builder.py

@@ -40,12 +40,12 @@ def _sigil_builder_view(request):
         {
             "prefix": "ENV",
             "url": reverse("admin:environment"),
-            "label": _("Environ"),
+            "label": _("Environment"),
         },
         {
             "prefix": "CONF",
             "url": reverse("admin:config"),
-            "label": _("Config"),
+            "label": _("Django Config"),
         },
         {
             "prefix": "SYS",

core/sigil_resolver.py

@@ -1,8 +1,5 @@
 import logging
 import os
-import shutil
-import subprocess
-from functools import lru_cache
 from typing import Optional
 
 from django.apps import apps
@@ -16,15 +13,6 @@ from .system import get_system_sigil_values, resolve_system_namespace_value
 logger = logging.getLogger("core.entity")
 
 
-def _is_wizard_mode() -> bool:
-    """Return ``True`` when the application is running in wizard mode."""
-
-    flag = getattr(settings, "WIZARD_MODE", False)
-    if isinstance(flag, str):
-        return flag.lower() in {"1", "true", "yes", "on"}
-    return bool(flag)
-
-
 def _first_instance(model: type[models.Model]) -> Optional[models.Model]:
     qs = model.objects
     ordering = list(getattr(model._meta, "ordering", []))
@@ -35,58 +23,8 @@ def _first_instance(model: type[models.Model]) -> Optional[models.Model]:
     return qs.first()
 
 
-@lru_cache(maxsize=1)
-def _find_gway_command() -> Optional[str]:
-    path = shutil.which("gway")
-    if path:
-        return path
-    for candidate in ("~/.local/bin/gway", "/usr/local/bin/gway"):
-        expanded = os.path.expanduser(candidate)
-        if os.path.isfile(expanded) and os.access(expanded, os.X_OK):
-            return expanded
-    return None
-
-
-def _resolve_with_gway(sigil: str) -> Optional[str]:
-    command = _find_gway_command()
-    if not command:
-        return None
-    timeout = 60 if _is_wizard_mode() else 1
-    try:
-        result = subprocess.run(
-            [command, "-e", sigil],
-            check=False,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            timeout=timeout,
-        )
-    except subprocess.TimeoutExpired:
-        logger.warning(
-            "gway timed out after %s seconds while resolving sigil %s",
-            timeout,
-            sigil,
-        )
-        return None
-    except Exception:
-        logger.exception("Failed executing gway for sigil %s", sigil)
-        return None
-    if result.returncode != 0:
-        logger.warning(
-            "gway exited with status %s while resolving sigil %s",
-            result.returncode,
-            sigil,
-        )
-        return None
-    return result.stdout.strip()
-
-
 def _failed_resolution(token: str) -> str:
-    sigil = f"[{token}]"
-    resolved = _resolve_with_gway(sigil)
-    if resolved is not None:
-        return resolved
-    return sigil
+    return f"[{token}]"
 
 
 def _resolve_token(token: str, current: Optional[models.Model] = None) -> str:
@@ -197,9 +135,6 @@ def _resolve_token(token: str, current: Optional[models.Model] = None) -> str:
                     value = getattr(settings, candidate, sentinel)
                     if value is not sentinel:
                         return str(value)
-                fallback = _resolve_with_gway(f"[{original_token}]")
-                if fallback is not None:
-                    return fallback
                 return ""
             if root.prefix.upper() == "SYS":
                 values = get_system_sigil_values()

core/system.py

@@ -4,6 +4,7 @@ from collections import deque
 from contextlib import closing
 from dataclasses import dataclass
 from datetime import datetime
+from functools import lru_cache
 from pathlib import Path
 import json
 import re
@@ -12,9 +13,12 @@ import subprocess
 import shutil
 import logging
 from typing import Callable, Iterable, Optional
+from urllib.parse import urlparse
 
+from django import forms
 from django.conf import settings
 from django.contrib import admin, messages
+from django.forms import modelformset_factory
 from django.template.response import TemplateResponse
 from django.http import HttpResponseRedirect
 from django.urls import path, reverse
@@ -32,6 +36,7 @@ from core.release import (
     _remote_with_credentials,
 )
 from core.tasks import check_github_updates
+from core.models import Todo
 from utils import revision
 
 
@@ -43,6 +48,69 @@ AUTO_UPGRADE_LOG_NAME = "auto-upgrade.log"
 logger = logging.getLogger(__name__)
 
 
+def _github_repo_path(remote_url: str | None) -> str:
+    """Return the ``owner/repo`` path for a GitHub *remote_url* if possible."""
+
+    if not remote_url:
+        return ""
+
+    normalized = remote_url.strip()
+    if not normalized:
+        return ""
+
+    path = ""
+    if normalized.startswith("git@"):
+        host, _, remainder = normalized.partition(":")
+        if "github.com" not in host.lower():
+            return ""
+        path = remainder
+    else:
+        parsed = urlparse(normalized)
+        if "github.com" not in parsed.netloc.lower():
+            return ""
+        path = parsed.path
+
+    path = path.strip("/")
+    if path.endswith(".git"):
+        path = path[: -len(".git")]
+
+    if not path:
+        return ""
+
+    segments = [segment for segment in path.split("/") if segment]
+    if len(segments) < 2:
+        return ""
+
+    owner, repo = segments[-2], segments[-1]
+    return f"{owner}/{repo}"
+
+
+@lru_cache()
+def _github_commit_url_base() -> str:
+    """Return the GitHub commit URL template for the configured repository."""
+
+    try:
+        remote_url = _git_remote_url()
+    except FileNotFoundError:  # pragma: no cover - depends on environment setup
+        logger.debug("Skipping GitHub commit URL generation; git executable not found")
+        remote_url = None
+
+    repo_path = _github_repo_path(remote_url)
+    if not repo_path:
+        return ""
+    return f"https://github.com/{repo_path}/commit/{{sha}}"
+
+
+def _github_commit_url(sha: str) -> str:
+    """Return the GitHub commit URL for *sha* when available."""
+
+    base = _github_commit_url_base()
+    clean_sha = (sha or "").strip()
+    if not base or not clean_sha:
+        return ""
+    return base.replace("{sha}", clean_sha)
+
+
 def _auto_upgrade_mode_file(base_dir: Path) -> Path:
     return base_dir / "locks" / AUTO_UPGRADE_LOCK_NAME
 
@@ -93,11 +161,77 @@ def _open_changelog_entries() -> list[dict[str, str]]:
         parts = trimmed.split(" ", 1)
         sha = parts[0]
         message = parts[1] if len(parts) > 1 else ""
-        entries.append({"sha": sha, "message": message})
+        entries.append({"sha": sha, "message": message, "url": _github_commit_url(sha)})
 
     return entries
 
 
+def _latest_release_changelog() -> dict[str, object]:
+    """Return the most recent tagged release entries for display."""
+
+    changelog_path = Path("CHANGELOG.rst")
+    try:
+        text = changelog_path.read_text(encoding="utf-8")
+    except (FileNotFoundError, OSError):
+        return {"title": "", "entries": []}
+
+    lines = text.splitlines()
+    state = "before"
+    release_title = ""
+    entries: list[dict[str, str]] = []
+
+    for raw_line in lines:
+        stripped = raw_line.strip()
+
+        if state == "before":
+            if stripped == "Unreleased":
+                state = "unreleased-heading"
+            continue
+
+        if state == "unreleased-heading":
+            if set(stripped) == {"-"}:
+                state = "unreleased-body"
+            else:
+                state = "unreleased-body"
+            continue
+
+        if state == "unreleased-body":
+            if not stripped:
+                state = "after-unreleased"
+            continue
+
+        if state == "after-unreleased":
+            if not stripped:
+                continue
+            release_title = stripped
+            state = "release-heading"
+            continue
+
+        if state == "release-heading":
+            if set(stripped) == {"-"}:
+                state = "release-body"
+            else:
+                state = "release-body"
+            continue
+
+        if state == "release-body":
+            if not stripped:
+                if entries:
+                    break
+                continue
+            if not stripped.startswith("- "):
+                break
+            trimmed = stripped[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, "url": _github_commit_url(sha)})
+
+    return {"title": release_title, "entries": entries}
+
+
 def _exclude_changelog_entries(shas: Iterable[str]) -> int:
     """Remove entries matching ``shas`` from the changelog.
 
@@ -171,7 +305,7 @@ def _regenerate_changelog() -> None:
     previous_text = (
         changelog_path.read_text(encoding="utf-8") if changelog_path.exists() else None
     )
-    range_spec = changelog_utils.determine_range_spec()
+    range_spec = changelog_utils.determine_range_spec(previous_text=previous_text)
     sections = changelog_utils.collect_sections(
         range_spec=range_spec, previous_text=previous_text
     )
@@ -1070,6 +1204,7 @@ def _system_changelog_report_view(request):
         {
             "title": _("Changelog Report"),
             "open_changelog_entries": _open_changelog_entries(),
+            "latest_release_changelog": _latest_release_changelog(),
         }
     )
     return TemplateResponse(request, "admin/system_changelog_report.html", context)
@@ -1086,6 +1221,132 @@ def _system_upgrade_report_view(request):
     return TemplateResponse(request, "admin/system_upgrade_report.html", context)
 
 
+class PendingTodoForm(forms.ModelForm):
+    mark_done = forms.BooleanField(required=False, label=_("Approve"))
+
+    class Meta:
+        model = Todo
+        fields = [
+            "request",
+            "request_details",
+            "url",
+            "generated_for_version",
+            "generated_for_revision",
+            "on_done_condition",
+        ]
+        widgets = {
+            "request_details": forms.Textarea(attrs={"rows": 3}),
+            "on_done_condition": forms.Textarea(attrs={"rows": 2}),
+        }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        for name in [
+            "request",
+            "url",
+            "generated_for_version",
+            "generated_for_revision",
+        ]:
+            self.fields[name].widget.attrs.setdefault("class", "vTextField")
+        for name in ["request_details", "on_done_condition"]:
+            self.fields[name].widget.attrs.setdefault("class", "vLargeTextField")
+
+        mark_done_widget = self.fields["mark_done"].widget
+        existing_classes = mark_done_widget.attrs.get("class", "").split()
+        if "approve-checkbox" not in existing_classes:
+            existing_classes.append("approve-checkbox")
+        mark_done_widget.attrs["class"] = " ".join(
+            class_name for class_name in existing_classes if class_name
+        )
+
+
+PendingTodoFormSet = modelformset_factory(Todo, form=PendingTodoForm, extra=0)
+
+
+def _system_pending_todos_report_view(request):
+    queryset = (
+        Todo.objects.filter(is_deleted=False, done_on__isnull=True)
+        .order_by("request")
+    )
+    formset = PendingTodoFormSet(
+        request.POST or None,
+        queryset=queryset,
+        prefix="todos",
+    )
+
+    if request.method == "POST":
+        if formset.is_valid():
+            approved_count = 0
+            edited_count = 0
+            for form in formset.forms:
+                mark_done = form.cleaned_data.get("mark_done")
+                todo = form.save(commit=False)
+                has_changes = form.has_changed()
+                if mark_done and todo.done_on is None:
+                    todo.done_on = timezone.now()
+                    todo.populate_done_metadata(request.user)
+                    approved_count += 1
+                    has_changes = True
+                if has_changes:
+                    todo.save()
+                    if form.has_changed():
+                        edited_count += 1
+                if has_changes and form.has_changed():
+                    form.save_m2m()
+
+            if approved_count or edited_count:
+                message_parts: list[str] = []
+                if edited_count:
+                    message_parts.append(
+                        ngettext(
+                            "%(count)d TODO updated.",
+                            "%(count)d TODOs updated.",
+                            edited_count,
+                        )
+                        % {"count": edited_count}
+                    )
+                if approved_count:
+                    message_parts.append(
+                        ngettext(
+                            "%(count)d TODO approved.",
+                            "%(count)d TODOs approved.",
+                            approved_count,
+                        )
+                        % {"count": approved_count}
+                    )
+                messages.success(request, " ".join(message_parts))
+            else:
+                messages.info(
+                    request,
+                    _("No changes were applied to the pending TODOs."),
+                )
+            return HttpResponseRedirect(reverse("admin:system-pending-todos-report"))
+        else:
+            messages.error(request, _("Please correct the errors below."))
+
+    rows = [
+        {
+            "form": form,
+            "todo": form.instance,
+        }
+        for form in formset.forms
+    ]
+
+    context = admin.site.each_context(request)
+    context.update(
+        {
+            "title": _("Pending TODOs Report"),
+            "formset": formset,
+            "rows": rows,
+        }
+    )
+    return TemplateResponse(
+        request,
+        "admin/system_pending_todos_report.html",
+        context,
+    )
+
+
 def _trigger_upgrade_check() -> bool:
     """Return ``True`` when the upgrade check was queued asynchronously."""
 
@@ -1142,6 +1403,11 @@ def patch_admin_system_view() -> None:
                 admin.site.admin_view(_system_changelog_report_view),
                 name="system-changelog-report",
             ),
+            path(
+                "system/pending-todos-report/",
+                admin.site.admin_view(_system_pending_todos_report_view),
+                name="system-pending-todos-report",
+            ),
             path(
                 "system/upgrade-report/",
                 admin.site.admin_view(_system_upgrade_report_view),