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

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.
 
@@ -711,8 +726,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/system.py

@@ -171,7 +171,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
     )

core/tasks.py

@@ -230,12 +230,6 @@ def check_github_updates() -> None:
 
     subprocess.run(args, cwd=base_dir, check=True)
 
-    if shutil.which("gway"):
-        try:
-            subprocess.run(["gway", "upgrade"], check=True)
-        except subprocess.CalledProcessError:
-            logger.warning("gway upgrade failed; continuing anyway", exc_info=True)
-
     service_file = base_dir / "locks/service.lck"
     if service_file.exists():
         service = service_file.read_text().strip()

core/tests.py

@@ -20,6 +20,7 @@ import types
 from glob import glob
 from datetime import datetime, timedelta, timezone as datetime_timezone
 import tempfile
+from io import StringIO
 from urllib.parse import quote
 
 from django.utils import timezone
@@ -57,6 +58,7 @@ from nodes.models import ContentSample
 
 from django.core.exceptions import ValidationError
 from django.core.management import call_command
+from django.core.management.base import CommandError
 from django.db import IntegrityError
 from .backends import LocalhostAdminBackend
 from core.views import (
@@ -548,6 +550,15 @@ class RFIDValidationTests(TestCase):
         tag = RFID.objects.create(rfid="DEADBEEF10")
         self.assertEqual(tag.rfid, "DEADBEEF10")
 
+    def test_reversed_uid_updates_with_rfid(self):
+        tag = RFID.objects.create(rfid="A1B2C3D4")
+        self.assertEqual(tag.reversed_uid, "D4C3B2A1")
+
+        tag.rfid = "112233"
+        tag.save(update_fields=["rfid"])
+        tag.refresh_from_db()
+        self.assertEqual(tag.reversed_uid, "332211")
+
     def test_find_user_by_rfid(self):
         user = User.objects.create_user(username="finder", password="pwd")
         acc = EnergyAccount.objects.create(user=user, name="FINDER")
@@ -983,6 +994,40 @@ class RFIDImportExportCommandTests(TestCase):
         self.assertTrue(tag.energy_accounts.filter(pk=account.pk).exists())
 
 
+class CheckRFIDCommandTests(TestCase):
+    def test_successful_validation_outputs_json(self):
+        out = StringIO()
+
+        call_command("check_rfid", "abcd1234", stdout=out)
+
+        payload = json.loads(out.getvalue())
+        self.assertEqual(payload["rfid"], "ABCD1234")
+        self.assertTrue(payload["created"])
+        self.assertTrue(RFID.objects.filter(rfid="ABCD1234").exists())
+
+    def test_invalid_value_raises_error(self):
+        with self.assertRaises(CommandError):
+            call_command("check_rfid", "invalid!")
+
+    def test_kind_option_updates_existing_tag(self):
+        tag = RFID.objects.create(rfid="EXISTING", allowed=False, kind=RFID.CLASSIC)
+        out = StringIO()
+
+        call_command(
+            "check_rfid",
+            "existing",
+            "--kind",
+            RFID.NTAG215,
+            stdout=out,
+        )
+
+        payload = json.loads(out.getvalue())
+        tag.refresh_from_db()
+        self.assertFalse(payload["created"])
+        self.assertEqual(payload["kind"], RFID.NTAG215)
+        self.assertEqual(tag.kind, RFID.NTAG215)
+
+
 class RFIDKeyVerificationFlagTests(TestCase):
     def test_flags_reset_on_key_change(self):
         tag = RFID.objects.create(
@@ -1037,6 +1082,44 @@ class ReleaseProcessTests(TestCase):
         )
         sync_main.assert_called_once_with(Path("rel.log"))
 
+    def test_step_check_todos_logs_instruction_when_pending(self):
+        log_path = Path("rel.log")
+        log_path.unlink(missing_ok=True)
+        Todo.objects.create(request="Review checklist")
+        ctx: dict[str, object] = {}
+
+        try:
+            with self.assertRaises(core_views.PendingTodos):
+                core_views._step_check_todos(self.release, ctx, log_path)
+
+            contents = log_path.read_text(encoding="utf-8")
+            message = "Release checklist requires acknowledgment before continuing."
+            self.assertIn(message, contents)
+            self.assertIn("Review outstanding TODO items", contents)
+
+            with self.assertRaises(core_views.PendingTodos):
+                core_views._step_check_todos(self.release, ctx, log_path)
+
+            contents = log_path.read_text(encoding="utf-8")
+            self.assertEqual(contents.count(message), 1)
+        finally:
+            log_path.unlink(missing_ok=True)
+
+    def test_step_check_todos_auto_ack_when_no_pending(self):
+        log_path = Path("rel.log")
+        log_path.unlink(missing_ok=True)
+        ctx: dict[str, object] = {}
+
+        try:
+            with mock.patch("core.views._refresh_changelog_once"):
+                core_views._step_check_todos(self.release, ctx, log_path)
+        finally:
+            log_path.unlink(missing_ok=True)
+
+        self.assertTrue(ctx.get("todos_ack"))
+        self.assertNotIn("todos_required", ctx)
+        self.assertIsNone(ctx.get("todos"))
+
     @mock.patch("core.views._sync_with_origin_main")
     @mock.patch("core.views.release_utils._git_clean", return_value=True)
     @mock.patch("core.views.release_utils.network_available", return_value=False)
@@ -1527,6 +1610,54 @@ class ReleaseProcessTests(TestCase):
         ctx = session.get(f"release_publish_{self.release.pk}")
         self.assertTrue(ctx.get("dry_run"))
 
+    def test_resume_button_shown_when_credentials_missing(self):
+        user = User.objects.create_superuser("admin", "admin@example.com", "pw")
+        url = reverse("release-progress", args=[self.release.pk, "publish"])
+        self.client.force_login(user)
+
+        self.client.get(f"{url}?start=1")
+
+        session = self.client.session
+        ctx = session.get(f"release_publish_{self.release.pk}") or {}
+        ctx.update({"step": 7, "started": True, "paused": False})
+        session[f"release_publish_{self.release.pk}"] = ctx
+        session.save()
+
+        response = self.client.get(f"{url}?step=7")
+        self.assertEqual(response.status_code, 200)
+        context = response.context
+        if isinstance(context, list):
+            context = context[-1]
+        self.assertTrue(context["resume_available"])
+        self.assertIn(b"Resume Publish", response.content)
+
+    def test_resume_without_step_parameter_defaults_to_current_progress(self):
+        run: list[str] = []
+
+        def step_fn(release, ctx, log_path):
+            run.append("step")
+
+        steps = [("Only step", step_fn)]
+        user = User.objects.create_superuser("admin", "admin@example.com", "pw")
+        url = reverse("release-progress", args=[self.release.pk, "publish"])
+        with mock.patch("core.views.PUBLISH_STEPS", steps):
+            self.client.force_login(user)
+            session = self.client.session
+            session[f"release_publish_{self.release.pk}"] = {
+                "step": 0,
+                "started": True,
+                "paused": False,
+            }
+            session.save()
+
+            response = self.client.get(f"{url}?resume=1")
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(run, ["step"])
+
+            session = self.client.session
+            ctx = session.get(f"release_publish_{self.release.pk}")
+            self.assertEqual(ctx.get("step"), 1)
+
     def test_new_todo_does_not_reset_pending_flow(self):
         user = User.objects.create_superuser("admin", "admin@example.com", "pw")
         url = reverse("release-progress", args=[self.release.pk, "publish"])

core/views.py

@@ -43,6 +43,7 @@ logger = logging.getLogger(__name__)
 PYPI_REQUEST_TIMEOUT = 10
 
 from . import changelog as changelog_utils
+from . import temp_passwords
 from .models import OdooProfile, Product, EnergyAccount, PackageRelease, Todo
 from .models import RFID
 
@@ -336,6 +337,35 @@ def odoo_quote_report(request):
     return TemplateResponse(request, "admin/core/odoo_quote_report.html", context)
 
 
+@staff_member_required
+@require_GET
+def request_temp_password(request):
+    """Generate a temporary password for the authenticated staff member."""
+
+    user = request.user
+    username = user.get_username()
+    password = temp_passwords.generate_password()
+    entry = temp_passwords.store_temp_password(
+        username,
+        password,
+        allow_change=True,
+    )
+    context = {
+        **admin_site.each_context(request),
+        "title": _("Temporary password"),
+        "username": username,
+        "password": password,
+        "expires_at": timezone.localtime(entry.expires_at),
+        "allow_change": entry.allow_change,
+        "return_url": reverse("admin:password_change"),
+    }
+    return TemplateResponse(
+        request,
+        "admin/core/request_temp_password.html",
+        context,
+    )
+
+
 @require_GET
 def version_info(request):
     """Return the running application version and Git revision."""
@@ -656,8 +686,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"):
@@ -897,7 +927,18 @@ def _step_check_todos(release, ctx, log_path: Path) -> None:
     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()
@@ -1451,12 +1492,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}/"
     )
@@ -1804,8 +1862,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:
@@ -1814,26 +1880,39 @@ 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)
-    if ack_todos_requested:
-        if pending_items:
-            failures = []
-            for todo in pending_items:
-                result = todo.check_on_done_condition()
-                if not result.passed:
-                    failures.append((todo, result))
-            if failures:
-                ctx.pop("todos_ack", None)
-                for todo, result in failures:
-                    messages.error(request, _format_condition_failure(todo, result))
-            else:
-                ctx["todos_ack"] = True
+    if not pending_items:
+        ctx["todos_ack"] = True
+        ctx["todos_ack_auto"] = True
+    elif ack_todos_requested:
+        failures = []
+        for todo in pending_items:
+            result = todo.check_on_done_condition()
+            if not result.passed:
+                failures.append((todo, result))
+        if failures:
+            ctx["todos_ack"] = False
+            ctx.pop("todos_ack_auto", None)
+            for todo, result in failures:
+                messages.error(request, _format_condition_failure(todo, result))
         else:
             ctx["todos_ack"] = True
+            ctx.pop("todos_ack_auto", None)
+    else:
+        if ctx.pop("todos_ack_auto", None):
+            ctx["todos_ack"] = False
+        else:
+            ctx.setdefault("todos_ack", False)
 
-    if not ctx.get("todos_ack"):
+    if ctx.get("todos_ack"):
+        ctx.pop("todos_block_logged", None)
+        ctx.pop("todos", None)
+        ctx.pop("todos_required", None)
+    else:
         ctx["todos"] = [
             {
                 "id": todo.pk,
@@ -1844,9 +1923,6 @@ 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:
@@ -1856,6 +1932,8 @@ def release_progress(request, pk: int, action: str):
             "started": ctx.get("started", False),
         }
         step_count = 0
+        if not pending_items:
+            ctx["todos_ack"] = True
     log_path = log_dir / log_name
     ctx.setdefault("log", log_name)
     ctx.setdefault("paused", False)
@@ -2049,6 +2127,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:
@@ -2103,9 +2189,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"):

ocpp/admin.py

@@ -29,6 +29,7 @@ from .transactions_io import (
     import_transactions as import_transactions_data,
 )
 from .status_display import STATUS_BADGE_MAP, ERROR_OK_VALUES
+from .views import _charger_state, _live_sessions
 from core.admin import SaveBeforeChangeAction
 from core.user_data import EntityModelAdmin
 
@@ -253,6 +254,8 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
     actions = [
         "purge_data",
         "fetch_cp_configuration",
+        "toggle_rfid_authentication",
+        "recheck_charger_status",
         "change_availability_operative",
         "change_availability_inoperative",
         "set_availability_state_operative",
@@ -317,16 +320,14 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
             "charger-status-connector",
             args=[obj.charger_id, obj.connector_slug],
         )
-        label = (obj.last_status or "status").strip() or "status"
-        status_key = label.lower()
-        error_code = (obj.last_error_code or "").strip().lower()
-        if (
-            self._has_active_session(obj)
-            and error_code in ERROR_OK_VALUES
-            and (status_key not in STATUS_BADGE_MAP or status_key == "available")
-        ):
-            label = STATUS_BADGE_MAP["charging"][0]
-        return format_html('<a href="{}" target="_blank">{}</a>', url, label)
+        tx_obj = store.get_transaction(obj.charger_id, obj.connector_id)
+        state, _ = _charger_state(
+            obj,
+            tx_obj
+            if obj.connector_id is not None
+            else (_live_sessions(obj) or None),
+        )
+        return format_html('<a href="{}" target="_blank">{}</a>', url, state)
 
     status_link.short_description = "Status"
 
@@ -359,6 +360,63 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
 
     purge_data.short_description = "Purge data"
 
+    @admin.action(description="Re-check Charger Status")
+    def recheck_charger_status(self, request, queryset):
+        requested = 0
+        for charger in queryset:
+            connector_value = charger.connector_id
+            ws = store.get_connection(charger.charger_id, connector_value)
+            if ws is None:
+                self.message_user(
+                    request,
+                    f"{charger}: no active connection",
+                    level=messages.ERROR,
+                )
+                continue
+            payload: dict[str, object] = {"requestedMessage": "StatusNotification"}
+            trigger_connector: int | None = None
+            if connector_value is not None:
+                payload["connectorId"] = connector_value
+                trigger_connector = connector_value
+            message_id = uuid.uuid4().hex
+            msg = json.dumps([2, message_id, "TriggerMessage", payload])
+            try:
+                async_to_sync(ws.send)(msg)
+            except Exception as exc:  # pragma: no cover - network error
+                self.message_user(
+                    request,
+                    f"{charger}: failed to send TriggerMessage ({exc})",
+                    level=messages.ERROR,
+                )
+                continue
+            log_key = store.identity_key(charger.charger_id, connector_value)
+            store.add_log(log_key, f"< {msg}", log_type="charger")
+            store.register_pending_call(
+                message_id,
+                {
+                    "action": "TriggerMessage",
+                    "charger_id": charger.charger_id,
+                    "connector_id": connector_value,
+                    "log_key": log_key,
+                    "trigger_target": "StatusNotification",
+                    "trigger_connector": trigger_connector,
+                    "requested_at": timezone.now(),
+                },
+            )
+            store.schedule_call_timeout(
+                message_id,
+                timeout=5.0,
+                action="TriggerMessage",
+                log_key=log_key,
+                message="TriggerMessage StatusNotification timed out",
+            )
+            requested += 1
+        if requested:
+            self.message_user(
+                request,
+                f"Requested status update from {requested} charger(s)",
+            )
+
     @admin.action(description="Fetch CP configuration")
     def fetch_cp_configuration(self, request, queryset):
         fetched = 0
@@ -413,6 +471,30 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
                 f"Requested configuration from {fetched} charger(s)",
             )
 
+    @admin.action(description="Toggle RFID Authentication")
+    def toggle_rfid_authentication(self, request, queryset):
+        enabled = 0
+        disabled = 0
+        for charger in queryset:
+            new_value = not charger.require_rfid
+            Charger.objects.filter(pk=charger.pk).update(require_rfid=new_value)
+            charger.require_rfid = new_value
+            if new_value:
+                enabled += 1
+            else:
+                disabled += 1
+        if enabled or disabled:
+            changes = []
+            if enabled:
+                changes.append(f"enabled for {enabled} charger(s)")
+            if disabled:
+                changes.append(f"disabled for {disabled} charger(s)")
+            summary = "; ".join(changes)
+            self.message_user(
+                request,
+                f"Updated RFID authentication: {summary}",
+            )
+
     def _dispatch_change_availability(self, request, queryset, availability_type: str):
         sent = 0
         for charger in queryset: