arthexis 0.1.16__tar.gz → 0.1.18__tar.gz

{arthexis-0.1.16 → arthexis-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arthexis
-Version: 0.1.16
+Version: 0.1.18
 Summary: Power & Energy Infrastructure
 Author-email: "Rafael J. Guillén-Osorio" <tecnologia@gelectriic.com>
 License-Expression: GPL-3.0-only

{arthexis-0.1.16 → arthexis-0.1.18}/arthexis.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arthexis
-Version: 0.1.16
+Version: 0.1.18
 Summary: Power & Energy Infrastructure
 Author-email: "Rafael J. Guillén-Osorio" <tecnologia@gelectriic.com>
 License-Expression: GPL-3.0-only

{arthexis-0.1.16 → arthexis-0.1.18}/arthexis.egg-info/SOURCES.txt

@@ -107,6 +107,7 @@ pages/forms.py
 pages/middleware.py
 pages/models.py
 pages/module_defaults.py
+pages/site_config.py
 pages/tasks.py
 pages/tests.py
 pages/urls.py
@@ -207,6 +208,7 @@ tests/test_release_progress.py
 tests/test_release_progress_pre_release_integration.py
 tests/test_release_push.py
 tests/test_release_tasks.py
+tests/test_render_nginx_sites.py
 tests/test_request_invite.py
 tests/test_rfid_admin_print_labels.py
 tests/test_rfid_admin_reference_clear.py

arthexis-0.1.18/config/middleware.py

@@ -0,0 +1,71 @@
+import socket
+from django.core.exceptions import DisallowedHost
+from django.http import HttpResponsePermanentRedirect
+from nodes.models import Node
+from utils.sites import get_site
+
+from .active_app import set_active_app
+
+
+class ActiveAppMiddleware:
+    """Store the current app based on the request's site."""
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        site = get_site(request)
+        node = Node.get_local()
+        role_name = node.role.name if node and node.role else "Terminal"
+        active = site.name or role_name
+        set_active_app(active)
+        request.site = site
+        request.active_app = active
+        try:
+            response = self.get_response(request)
+        finally:
+            set_active_app(socket.gethostname())
+        return response
+
+
+def _is_https_request(request) -> bool:
+    if request.is_secure():
+        return True
+
+    forwarded_proto = request.META.get("HTTP_X_FORWARDED_PROTO", "")
+    if forwarded_proto:
+        candidate = forwarded_proto.split(",")[0].strip().lower()
+        if candidate == "https":
+            return True
+
+    forwarded_header = request.META.get("HTTP_FORWARDED", "")
+    for forwarded_part in forwarded_header.split(","):
+        for element in forwarded_part.split(";"):
+            key, _, value = element.partition("=")
+            if key.strip().lower() == "proto" and value.strip().strip('"').lower() == "https":
+                return True
+
+    return False
+
+
+class SiteHttpsRedirectMiddleware:
+    """Redirect HTTP traffic to HTTPS for sites that require it."""
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        site = getattr(request, "site", None)
+        if site is None:
+            site = get_site(request)
+            request.site = site
+
+        if getattr(site, "require_https", False) and not _is_https_request(request):
+            try:
+                host = request.get_host()
+            except DisallowedHost:  # pragma: no cover - defensive guard
+                host = request.META.get("HTTP_HOST", "")
+            redirect_url = f"https://{host}{request.get_full_path()}"
+            return HttpResponsePermanentRedirect(redirect_url)
+
+        return self.get_response(request)

{arthexis-0.1.16 → arthexis-0.1.18}/config/settings.py

@@ -390,6 +390,7 @@ MIDDLEWARE = [
     "whitenoise.middleware.WhiteNoiseMiddleware",
     "django.contrib.sessions.middleware.SessionMiddleware",
     "config.middleware.ActiveAppMiddleware",
+    "config.middleware.SiteHttpsRedirectMiddleware",
     "django.middleware.locale.LocaleMiddleware",
     "django.middleware.common.CommonMiddleware",
     "django.middleware.csrf.CsrfViewMiddleware",
@@ -480,6 +481,9 @@ AUTHENTICATION_BACKENDS = [
     "core.backends.RFIDBackend",
 ]
 
+# Use the custom login view for all authentication redirects.
+LOGIN_URL = "pages:login"
+
 # Issuer name used when generating otpauth URLs for authenticator apps.
 OTP_TOTP_ISSUER = os.environ.get("OTP_TOTP_ISSUER", "Arthexis")
 

{arthexis-0.1.16 → arthexis-0.1.18}/config/urls.py

@@ -149,6 +149,11 @@ urlpatterns = [
         core_views.odoo_quote_report,
         name="odoo-quote-report",
     ),
+    path(
+        "admin/request-temp-password/",
+        core_views.request_temp_password,
+        name="admin-request-temp-password",
+    ),
     path("admin/", admin.site.urls),
     path("i18n/setlang/", csrf_exempt(set_language), name="set_language"),
     path("api/", include("core.workgroup_urls")),

{arthexis-0.1.16 → arthexis-0.1.18}/core/admin.py

@@ -1309,11 +1309,11 @@ class AssistantProfileInlineForm(ProfileFormMixin, forms.ModelForm):
         widget=forms.PasswordInput(render_value=True),
         help_text="Provide a plain key to create or rotate credentials.",
     )
-    profile_fields = ("user_key", "scopes", "is_active")
+    profile_fields = ("assistant_name", "user_key", "scopes", "is_active")
 
     class Meta:
         model = AssistantProfile
-        fields = ("scopes", "is_active")
+        fields = ("assistant_name", "scopes", "is_active")
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -1475,7 +1475,7 @@ PROFILE_INLINE_CONFIG = {
     },
     AssistantProfile: {
         "form": AssistantProfileInlineForm,
-        "fields": ("user_key", "scopes", "is_active"),
+        "fields": ("assistant_name", "user_key", "scopes", "is_active"),
         "readonly_fields": ("user_key_hash", "created_at", "last_used_at"),
         "template": "admin/edit_inline/profile_stacked.html",
     },
@@ -2016,7 +2016,7 @@ class EmailInboxAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmi
 class AssistantProfileAdmin(
     ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin
 ):
-    list_display = ("owner", "created_at", "last_used_at", "is_active")
+    list_display = ("assistant_name", "owner", "created_at", "last_used_at", "is_active")
     readonly_fields = ("user_key_hash", "created_at", "last_used_at")
 
     change_form_template = "admin/workgroupassistantprofile_change_form.html"
@@ -2028,7 +2028,15 @@ class AssistantProfileAdmin(
         ("Credentials", {"fields": ("user_key_hash",)}),
         (
             "Configuration",
-            {"fields": ("scopes", "is_active", "created_at", "last_used_at")},
+            {
+                "fields": (
+                    "assistant_name",
+                    "scopes",
+                    "is_active",
+                    "created_at",
+                    "last_used_at",
+                )
+            },
         ),
     )
 
@@ -2835,6 +2843,7 @@ class RFIDResource(resources.ModelResource):
             "post_auth_command",
             "allowed",
             "color",
+            "endianness",
             "kind",
             "released",
             "last_seen_on",
@@ -2849,6 +2858,7 @@ class RFIDResource(resources.ModelResource):
             "post_auth_command",
             "allowed",
             "color",
+            "endianness",
             "kind",
             "released",
             "last_seen_on",
@@ -2919,11 +2929,12 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
         "user_data_flag",
         "color",
         "kind",
+        "endianness",
         "released",
         "allowed",
         "last_seen_on",
     )
-    list_filter = ("color", "released", "allowed")
+    list_filter = ("color", "endianness", "released", "allowed")
     search_fields = ("label_id", "rfid", "custom_label")
     autocomplete_fields = ["energy_accounts"]
     raw_id_fields = ["reference"]
@@ -2933,8 +2944,10 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
         "print_release_form",
         "copy_rfids",
         "toggle_selected_user_data",
+        "toggle_selected_released",
+        "toggle_selected_allowed",
     ]
-    readonly_fields = ("added_on", "last_seen_on")
+    readonly_fields = ("added_on", "last_seen_on", "reversed_uid")
     form = RFIDForm
 
     def get_import_resource_kwargs(self, request, form=None, **kwargs):
@@ -3030,6 +3043,50 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
                 level=messages.WARNING,
             )
 
+    @admin.action(description=_("Toggle Released flag"))
+    def toggle_selected_released(self, request, queryset):
+        manager = getattr(self.model, "all_objects", self.model.objects)
+        toggled = 0
+        for tag in queryset:
+            new_state = not tag.released
+            manager.filter(pk=tag.pk).update(released=new_state)
+            tag.released = new_state
+            toggled += 1
+
+        if toggled:
+            self.message_user(
+                request,
+                ngettext(
+                    "Toggled released flag for %(count)d RFID.",
+                    "Toggled released flag for %(count)d RFIDs.",
+                    toggled,
+                )
+                % {"count": toggled},
+                level=messages.SUCCESS,
+            )
+
+    @admin.action(description=_("Toggle Allowed flag"))
+    def toggle_selected_allowed(self, request, queryset):
+        manager = getattr(self.model, "all_objects", self.model.objects)
+        toggled = 0
+        for tag in queryset:
+            new_state = not tag.allowed
+            manager.filter(pk=tag.pk).update(allowed=new_state)
+            tag.allowed = new_state
+            toggled += 1
+
+        if toggled:
+            self.message_user(
+                request,
+                ngettext(
+                    "Toggled allowed flag for %(count)d RFID.",
+                    "Toggled allowed flag for %(count)d RFIDs.",
+                    toggled,
+                )
+                % {"count": toggled},
+                level=messages.SUCCESS,
+            )
+
     @admin.action(description=_("Copy RFID"))
     def copy_rfids(self, request, queryset):
         if queryset.count() != 1:
@@ -3497,6 +3554,7 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
         context["title"] = _("Scan RFIDs")
         context["opts"] = self.model._meta
         context["show_release_info"] = True
+        context["default_endianness"] = RFID.BIG_ENDIAN
         return render(request, "admin/core/rfid/scan.html", context)
 
     def scan_next(self, request):
@@ -3510,9 +3568,11 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
                 return JsonResponse({"error": "Invalid JSON payload"}, status=400)
             rfid = payload.get("rfid") or payload.get("value")
             kind = payload.get("kind")
-            result = validate_rfid_value(rfid, kind=kind)
+            endianness = payload.get("endianness")
+            result = validate_rfid_value(rfid, kind=kind, endianness=endianness)
         else:
-            result = scan_sources(request)
+            endianness = request.GET.get("endianness")
+            result = scan_sources(request, endianness=endianness)
         status = 500 if result.get("error") else 200
         return JsonResponse(result, status=status)
 

{arthexis-0.1.16 → arthexis-0.1.18}/core/backends.py

@@ -90,6 +90,7 @@ class RFIDBackend:
             env = os.environ.copy()
             env["RFID_VALUE"] = rfid_value
             env["RFID_LABEL_ID"] = str(tag.pk)
+            env["RFID_ENDIANNESS"] = getattr(tag, "endianness", RFID.BIG_ENDIAN)
             try:
                 completed = subprocess.run(
                     command,
@@ -117,6 +118,7 @@ class RFIDBackend:
                 env = os.environ.copy()
                 env["RFID_VALUE"] = rfid_value
                 env["RFID_LABEL_ID"] = str(tag.pk)
+                env["RFID_ENDIANNESS"] = getattr(tag, "endianness", RFID.BIG_ENDIAN)
                 with contextlib.suppress(Exception):
                     subprocess.Popen(
                         post_command,

{arthexis-0.1.16 → arthexis-0.1.18}/core/changelog.py

@@ -154,9 +154,53 @@ def _parse_sections(text: str) -> List[ChangelogSection]:
     return sections
 
 
+def _latest_release_version(previous_text: str) -> Optional[str]:
+    for section in _parse_sections(previous_text):
+        if section.version:
+            return section.version
+    return None
+
+
+def _find_release_commit(version: str) -> Optional[str]:
+    normalized = version.lstrip("v")
+    search_terms = [
+        f"Release v{normalized}",
+        f"Release {normalized}",
+        f"pre-release commit v{normalized}",
+        f"pre-release commit {normalized}",
+    ]
+    for term in search_terms:
+        proc = subprocess.run(
+            [
+                "git",
+                "log",
+                "--max-count=1",
+                "--format=%H",
+                "--fixed-strings",
+                f"--grep={term}",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        sha = proc.stdout.strip()
+        if sha:
+            return sha.splitlines()[0]
+    return None
+
+
+def _resolve_release_commit_from_text(previous_text: str) -> Optional[str]:
+    version = _latest_release_version(previous_text)
+    if not version:
+        return None
+    return _find_release_commit(version)
+
+
 def _merge_sections(
     new_sections: Iterable[ChangelogSection],
     old_sections: Iterable[ChangelogSection],
+    *,
+    reopen_latest: bool = False,
 ) -> List[ChangelogSection]:
     merged = list(new_sections)
     old_sections_list = list(old_sections)
@@ -199,7 +243,8 @@ def _merge_sections(
         existing = version_to_section.get(old.version)
         if existing is None:
             if (
-                first_release_version
+                reopen_latest
+                and first_release_version
                 and old.version == first_release_version
                 and not reopened_latest_version
                 and unreleased_section is not None
@@ -274,29 +319,45 @@ def _resolve_start_tag(explicit: str | None = None) -> Optional[str]:
     return None
 
 
-def determine_range_spec(start_tag: str | None = None) -> str:
+def determine_range_spec(
+    start_tag: str | None = None, *, previous_text: str | None = None
+) -> str:
     """Return the git range specification to build the changelog."""
 
     resolved = _resolve_start_tag(start_tag)
     if resolved:
         return f"{resolved}..HEAD"
+
+    if previous_text:
+        release_commit = _resolve_release_commit_from_text(previous_text)
+        if release_commit:
+            return f"{release_commit}..HEAD"
+
     return "HEAD"
 
 
 def collect_sections(
-    *, range_spec: str = "HEAD", previous_text: str | None = None
+    *,
+    range_spec: str = "HEAD",
+    previous_text: str | None = None,
+    reopen_latest: bool = False,
 ) -> List[ChangelogSection]:
     """Return changelog sections for *range_spec*.
 
     When ``previous_text`` is provided, sections not regenerated in the current run
-    are appended so long as they can be parsed from the existing changelog.
+    are appended so long as they can be parsed from the existing changelog. Set
+    ``reopen_latest`` to ``True`` when the caller intends to move the most recent
+    release notes back into the ``Unreleased`` section (for example, when
+    preparing a release retry before a new tag is created).
     """
 
     commits = _read_commits(range_spec)
     sections = _sections_from_commits(commits)
     if previous_text:
         old_sections = _parse_sections(previous_text)
-        sections = _merge_sections(sections, old_sections)
+        sections = _merge_sections(
+            sections, old_sections, reopen_latest=reopen_latest
+        )
     return sections
 
 

{arthexis-0.1.16 → arthexis-0.1.18}/core/models.py

@@ -1775,6 +1775,14 @@ class RFID(Entity):
             )
         ],
     )
+    reversed_uid = models.CharField(
+        max_length=255,
+        default="",
+        blank=True,
+        editable=False,
+        verbose_name="Reversed UID",
+        help_text="UID value stored with opposite endianness for reference.",
+    )
     custom_label = models.CharField(
         max_length=32,
         blank=True,
@@ -1851,6 +1859,17 @@ class RFID(Entity):
         choices=KIND_CHOICES,
         default=CLASSIC,
     )
+    BIG_ENDIAN = "BIG"
+    LITTLE_ENDIAN = "LITTLE"
+    ENDIANNESS_CHOICES = [
+        (BIG_ENDIAN, _("Big endian")),
+        (LITTLE_ENDIAN, _("Little endian")),
+    ]
+    endianness = models.CharField(
+        max_length=6,
+        choices=ENDIANNESS_CHOICES,
+        default=BIG_ENDIAN,
+    )
     reference = models.ForeignKey(
         "Reference",
         null=True,
@@ -1895,13 +1914,24 @@ class RFID(Entity):
                 if self.key_b and old["key_b"] != self.key_b.upper():
                     self.key_b_verified = False
         if self.rfid:
-            self.rfid = self.rfid.upper()
+            normalized_rfid = self.rfid.upper()
+            self.rfid = normalized_rfid
+            reversed_uid = self.reverse_uid(normalized_rfid)
+            if reversed_uid != self.reversed_uid:
+                self.reversed_uid = reversed_uid
+                if update_fields:
+                    fields = set(update_fields)
+                    if "reversed_uid" not in fields:
+                        fields.add("reversed_uid")
+                        kwargs["update_fields"] = tuple(fields)
         if self.key_a:
             self.key_a = self.key_a.upper()
         if self.key_b:
             self.key_b = self.key_b.upper()
         if self.kind:
             self.kind = self.kind.upper()
+        if self.endianness:
+            self.endianness = self.normalize_endianness(self.endianness)
         super().save(*args, **kwargs)
         if not self.allowed:
             self.energy_accounts.clear()
@@ -1909,6 +1939,30 @@ class RFID(Entity):
     def __str__(self):  # pragma: no cover - simple representation
         return str(self.label_id)
 
+    @classmethod
+    def normalize_endianness(cls, value: object) -> str:
+        """Return a valid endianness value, defaulting to BIG."""
+
+        if isinstance(value, str):
+            candidate = value.strip().upper()
+            valid = {choice[0] for choice in cls.ENDIANNESS_CHOICES}
+            if candidate in valid:
+                return candidate
+        return cls.BIG_ENDIAN
+
+    @staticmethod
+    def reverse_uid(value: str) -> str:
+        """Return ``value`` with reversed byte order for reference storage."""
+
+        normalized = "".join((value or "").split()).upper()
+        if not normalized:
+            return ""
+        if len(normalized) % 2 != 0:
+            return normalized[::-1]
+        bytes_list = [normalized[index : index + 2] for index in range(0, len(normalized), 2)]
+        bytes_list.reverse()
+        return "".join(bytes_list)
+
     @classmethod
     def next_scan_label(
         cls, *, step: int | None = None, start: int | None = None
@@ -1971,13 +2025,39 @@ class RFID(Entity):
 
     @classmethod
     def register_scan(
-        cls, rfid: str, *, kind: str | None = None
+        cls,
+        rfid: str,
+        *,
+        kind: str | None = None,
+        endianness: str | None = None,
     ) -> tuple["RFID", bool]:
         """Return or create an RFID that was detected via scanning."""
 
-        normalized = (rfid or "").upper()
-        existing = cls.objects.filter(rfid=normalized).first()
+        normalized = "".join((rfid or "").split()).upper()
+        desired_endianness = cls.normalize_endianness(endianness)
+        alternate = None
+        if normalized and len(normalized) % 2 == 0:
+            bytes_list = [normalized[i : i + 2] for i in range(0, len(normalized), 2)]
+            bytes_list.reverse()
+            alternate_candidate = "".join(bytes_list)
+            if alternate_candidate != normalized:
+                alternate = alternate_candidate
+
+        existing = None
+        if normalized:
+            existing = cls.objects.filter(rfid=normalized).first()
+        if not existing and alternate:
+            existing = cls.objects.filter(rfid=alternate).first()
         if existing:
+            update_fields: list[str] = []
+            if normalized and existing.rfid != normalized:
+                existing.rfid = normalized
+                update_fields.append("rfid")
+            if existing.endianness != desired_endianness:
+                existing.endianness = desired_endianness
+                update_fields.append("endianness")
+            if update_fields:
+                existing.save(update_fields=update_fields)
             return existing, False
 
         attempts = 0
@@ -1990,6 +2070,7 @@ class RFID(Entity):
                 "rfid": normalized,
                 "allowed": True,
                 "released": False,
+                "endianness": desired_endianness,
             }
             if kind:
                 create_kwargs["kind"] = kind
@@ -3539,7 +3620,8 @@ class AssistantProfile(Profile):
     """
 
     id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
-    profile_fields = ("user_key_hash", "scopes", "is_active")
+    profile_fields = ("assistant_name", "user_key_hash", "scopes", "is_active")
+    assistant_name = models.CharField(max_length=100, default="Assistant")
     user_key_hash = models.CharField(max_length=64, unique=True)
     scopes = models.JSONField(default=list, blank=True)
     created_at = models.DateTimeField(auto_now_add=True)
@@ -3586,8 +3668,7 @@ class AssistantProfile(Profile):
         self.save(update_fields=["last_used_at"])
 
     def __str__(self) -> str:  # pragma: no cover - simple representation
-        owner = self.owner_display()
-        return f"AssistantProfile for {owner}" if owner else "AssistantProfile"
+        return self.assistant_name or "AssistantProfile"
 
 
 def validate_relative_url(value: str) -> None:

{arthexis-0.1.16 → arthexis-0.1.18}/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
 
 

{arthexis-0.1.16 → arthexis-0.1.18}/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
     )

{arthexis-0.1.16 → arthexis-0.1.18}/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()